如何将文本附加到Java中的现有文件中


How to append text to an existing file in Java

我需要将文本重复附加到Java中的现有文件中。 我怎么做？

你这样做是为了记录目的吗？如果是这样，那么有几个库。最受欢迎的两个是Log4j和Logback。

Java 7+

如果您只需要执行此操作，则Files类可以轻松实现：

1
2
3
4
5
try {
    Files.write(Paths.get("myfile.txt"),"the text".getBytes(), StandardOpenOption.APPEND);
}catch (IOException e) {
    //exception handling left as an exercise for the reader
}

小心：如果文件尚不存在，上面的方法将抛出NoSuchFileException。它也不会自动附加换行符(当您追加到文本文件时通常需要它)。 Steve Chambers的回答介绍了如何使用Files类来完成这项工作。

但是，如果您要多次写入同一文件，则必须多次打开和关闭磁盘上的文件，这是一个很慢的操作。在这种情况下，缓冲编写器更好：

1
2
3
4
5
6
7
8
9
10
11
try(FileWriter fw = new FileWriter("myfile.txt", true);
    BufferedWriter bw = new BufferedWriter(fw);
    PrintWriter out = new PrintWriter(bw))
{
    out.println("the text");
    //more code
    out.println("more text");
    //more code
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

笔记：

  • FileWriter构造函数的第二个参数将告诉它附加到文件，而不是写入新文件。 (如果该文件不存在，则会创建该文件。)
  • 对于昂贵的编写器(例如FileWriter)，建议使用BufferedWriter。
  • 使用PrintWriter可以访问System.out中可能习惯的println语法。
  • 但是BufferedWriter和PrintWriter包装并不是绝对必要的。

旧Java

1
2
3
4
5
6
7
try {
    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("myfile.txt", true)));
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

异常处理

如果您需要针对较旧的Java进行强大的异常处理，那么它会非常冗长：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
FileWriter fw = null;
BufferedWriter bw = null;
PrintWriter out = null;
try {
    fw = new FileWriter("myfile.txt", true);
    bw = new BufferedWriter(fw);
    out = new PrintWriter(bw);
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}
finally {
    try {
        if(out != null)
            out.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(bw != null)
            bw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(fw != null)
            fw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
}
相关讨论

您可以使用FileWriter并将标志设置为true进行追加。

1
2
3
4
5
6
7
8
9
10
11
12
try
{
    String filename="MyFile.txt";
    FileWriter fw = new FileWriter(filename,true); //the true will append the new data
    fw.write("add a line
");//appends the string to the file
    fw.close();
}
catch(IOException ioe)
{
    System.err.println("IOException:" + ioe.getMessage());
}
相关讨论

不应该使用try / catch块的所有答案都包含finally块中的.close()块吗？

标记答案的示例：

1
2
3
4
5
6
7
8
9
10
11
PrintWriter out = null;
try {
    out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)));
    out.println("the text");
} catch (IOException e) {
    System.err.println(e);
} finally {
    if (out != null) {
        out.close();
    }
}

此外，从Java 7开始，您可以使用try-with-resources语句。关闭声明的资源不需要finally块，因为它是自动处理的，并且也不那么详细：

1
2
3
4
5
try(PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)))) {
    out.println("the text");
} catch (IOException e) {
    System.err.println(e);
}
相关讨论

编辑 - 从Apache Commons 2.1开始，正确的方法是：

1
FileUtils.writeStringToFile(file,"String to append", true);

我改编了@Kip的解决方案，包括最终正确关闭文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void appendToFile(String targetFile, String s) throws IOException {
    appendToFile(new File(targetFile), s);
}

public static void appendToFile(File targetFile, String s) throws IOException {
    PrintWriter out = null;
    try {
        out = new PrintWriter(new BufferedWriter(new FileWriter(targetFile, true)));
        out.println(s);
    } finally {
        if (out != null) {
            out.close();
        }
    }
}

相关讨论

为了略微扩展基普的答案，
这是一个简单的Java 7+方法，用于将新行附加到文件中，如果它尚不存在则创建它：

1
2
3
4
5
6
7
try {
    final Path path = Paths.get("path/to/filename.txt");
    Files.write(path, Arrays.asList("New line to append"), StandardCharsets.UTF_8,
        Files.exists(path) ? StandardOpenOption.APPEND : StandardOpenOption.CREATE);
} catch (final IOException ioe) {
    // Add your own exception handling...
}

注意：上面使用Files.write重载将文本行写入文件(即类似于println命令)。要仅将文本写入末尾(即类似于print命令)，可以使用替代的Files.write重载，传入字节数组(例如"mytext".getBytes(StandardCharsets.UTF_8))。

相关讨论

确保在所有方案中正确关闭流。

令人担忧的是，如果出现错误，这些答案中有多少会使文件句柄保持打开状态。答案https://stackoverflow.com/a/15053443/2498188是钱，但只是因为BufferedWriter()不能扔。如果可能则异常会使FileWriter对象保持打开状态。

执行此操作的更一般方法不关心BufferedWriter()是否可以抛出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
  PrintWriter out = null;
  BufferedWriter bw = null;
  FileWriter fw = null;
  try{
     fw = new FileWriter("outfilename", true);
     bw = new BufferedWriter(fw);
     out = new PrintWriter(bw);
     out.println("the text");
  }
  catch( IOException e ){
     // File writing/opening failed at some stage.
  }
  finally{
     try{
        if( out != null ){
           out.close(); // Will close bw and fw too
        }
        else if( bw != null ){
           bw.close(); // Will close fw too
        }
        else if( fw != null ){
           fw.close();
        }
        else{
           // Oh boy did it fail hard! :3
        }
     }
     catch( IOException e ){
        // Closing the file writers failed for some obscure reason
     }
  }

编辑：

从Java 7开始，推荐的方法是使用"try with resources"并让JVM处理它：

1
2
3
4
5
6
7
8
  try(    FileWriter fw = new FileWriter("outfilename", true);
          BufferedWriter bw = new BufferedWriter(fw);
          PrintWriter out = new PrintWriter(bw)){
     out.println("the text");
  }  
  catch( IOException e ){
      // File writing/opening failed at some stage.
  }
相关讨论

在Java-7中它也可以这样做：

1
2
3
4
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

// ---------------------

1
2
3
4
5
Path filePath = Paths.get("someFile.txt");
if (!Files.exists(filePath)) {
    Files.createFile(filePath);
}
Files.write(filePath,"Text to be added".getBytes(), StandardOpenOption.APPEND);
相关讨论

java 7+

在我的拙见中，因为我是普通java的粉丝，我建议它是上述答案的组合。也许我迟到了。这是代码：

1
2
3
 String sampleText ="test" +  System.getProperty("line.separator");
 Files.write(Paths.get(filePath), sampleText.getBytes(StandardCharsets.UTF_8),
 StandardOpenOption.CREATE, StandardOpenOption.APPEND);

如果该文件不存在，则创建该文件，如果该文件已存在，则附加该文件
sampleText到现有文件。使用它，可以避免在类路径中添加不必要的库。

这可以在一行代码中完成。希望这可以帮助 ：)

1
Files.write(Paths.get(fileName), msg.getBytes(), StandardOpenOption.APPEND);
相关讨论

使用java.nio.Files和java.nio.file.StandardOpenOption

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    PrintWriter out = null;
    BufferedWriter bufWriter;

    try{
        bufWriter =
            Files.newBufferedWriter(
                Paths.get("log.txt"),
                Charset.forName("UTF8"),
                StandardOpenOption.WRITE,
                StandardOpenOption.APPEND,
                StandardOpenOption.CREATE);
        out = new PrintWriter(bufWriter, true);
    }catch(IOException e){
        //Oh, no! Failed to create PrintWriter
    }

    //After successful creation of PrintWriter
    out.println("Text to be appended");

    //After done writing, remember to close!
    out.close();

这将使用Files创建BufferedWriter，它接受StandardOpenOption参数，并从结果BufferedWriter创建自动刷新PrintWriter。然后可以调用PrintWriter的println()方法来写入文件。

此代码中使用的StandardOpenOption参数：打开要写入的文件，仅附加到文件，如果文件不存在则创建该文件。

Paths.get("path here")可以替换为new File("path here").toPath()。
并且可以修改Charset.forName("charset name")以适应期望的Charset。

我只是添加小细节：

1
    new FileWriter("outfilename", true)

2.nd参数(true)是一个名为appendable的特性(或接口)(http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html)。它负责能够将某些内容添加到特定文件/流的末尾。此接口从Java 1.5开始实现。具有此接口的每个对象(即BufferedWriter，CharArrayWriter，CharBuffer，FileWriter，FilterWriter，LogStream，OutputStreamWriter，PipedWriter，PrintStream，PrintWriter，StringBuffer，StringBuilder，StringWriter，Writer)可用于添加内容

换句话说，您可以向gzip压缩文件或某些http进程添加一些内容

样品，使用番石榴：

1
2
3
4
5
6
7
File to = new File("C:/test/test.csv");

for (int i = 0; i < 42; i++) {
    CharSequence from ="some string" + i +"
";
    Files.append(from, to, Charsets.UTF_8);
}
相关讨论

尝试使用bufferFileWriter.append，它适用于我。

1
2
3
4
5
6
7
8
9
10
FileWriter fileWriter;
try {
    fileWriter = new FileWriter(file,true);
    BufferedWriter bufferFileWriter = new BufferedWriter(fileWriter);
    bufferFileWriter.append(obj.toJSONString());
    bufferFileWriter.newLine();
    bufferFileWriter.close();
} catch (IOException ex) {
    Logger.getLogger(JsonTest.class.getName()).log(Level.SEVERE, null, ex);
}
相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    String str;
    String path ="C:/Users/...the path..../iin.txt"; // you can input also..i created this way :P

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw = new PrintWriter(new FileWriter(path, true));

    try
    {
       while(true)
        {
            System.out.println("Enter the text :");
            str = br.readLine();
            if(str.equalsIgnoreCase("exit"))
                break;
            else
                pw.println(str);
        }
    }
    catch (Exception e)
    {
        //oh noes!
    }
    finally
    {
        pw.close();        
    }

这将做你想要的..

最好使用try-with-resources然后所有java-7之前的业务

1
2
3
4
5
6
static void appendStringToFile(Path file, String s) throws IOException  {
    try (BufferedWriter out = Files.newBufferedWriter(file, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        out.append(s);
        out.newLine();
    }
}

如果我们使用Java 7及更高版本并且还知道要添加(附加)到文件的内容，我们可以在NIO包中使用newBufferedWriter方法。

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
    Path FILE_PATH = Paths.get("C:/temp","temp.txt");
    String text ="
 Welcome to Java 8";

    //Writing to the file temp.txt
    try (BufferedWriter writer = Files.newBufferedWriter(FILE_PATH, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        writer.write(text);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

有几点需要注意：

  • 指定charset编码总是一个好习惯，因为我们在类StandardCharsets中有常量。
  • 代码使用try-with-resource语句，其中资源在尝试后自动关闭。

    • 尽管OP没有提出要求，但万一我们想要搜索具有某些特定关键字的行，例如confidential我们可以在Java中使用流API：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //Reading from the file the first line which contains word"confidential"
    try {
        Stream<String> lines = Files.lines(FILE_PATH);
        Optional<String> containsJava = lines.filter(l->l.contains("confidential")).findFirst();
        if(containsJava.isPresent()){
            System.out.println(containsJava.get());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    相关讨论

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;

    public class Writer {


        public static void main(String args[]){
            doWrite("output.txt","Content to be appended to file");
        }

        public static void doWrite(String filePath,String contentToBeAppended){

           try(
                FileWriter fw = new FileWriter(filePath, true);
                BufferedWriter bw = new BufferedWriter(fw);
                PrintWriter out = new PrintWriter(bw)
              )
              {
                out.println(contentToBeAppended);
              }  
            catch( IOException e ){
            // File writing/opening failed at some stage.
            }

        }

    }
    相关讨论

    Library

    1
    2
    3
    4
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;

    Code

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public void append()
    {
        try
        {
            String path ="D:/sample.txt";

            File file = new File(path);

            FileWriter fileWriter = new FileWriter(file,true);

            BufferedWriter bufferFileWriter  = new BufferedWriter(fileWriter);

            fileWriter.append("Sample text in the file to append");

            bufferFileWriter.close();

            System.out.println("User Registration Completed");

        }catch(Exception ex)
        {
            System.out.println(ex);
        }
    }

    在项目的任何位置创建一个函数，只需在需要的地方调用该函数即可。

    伙计们你必须记住，你们正在调用你不是异步调用的活动线程，因为它可能是一个很好的5到10页来完成它。
    为什么不在你的项目上花更多的时间而忘记写任何已写的东西。
    正确

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
        //Adding a static modifier would make this accessible anywhere in your app

        public Logger getLogger()
        {
           return java.util.logging.Logger.getLogger("MyLogFileName");
        }
        //call the method anywhere and append what you want to log
        //Logger class will take care of putting timestamps for you
        //plus the are ansychronously done so more of the
        //processing power will go into your application

        //from inside a function body in the same class ...{...

        getLogger().log(Level.INFO,"the text you want to append");

        ...}...
        /*********log file resides in server root log files********/

    三行代码两个真的，因为第三行实际上附加了文本。 ：P

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    FileOutputStream stream = new FileOutputStream(path, true);
    try {

        stream.write(

            string.getBytes("UTF-8") // Choose your encoding.

        );

    } finally {
        stream.close();
    }

    然后在上游某处捕获IOException。

    1
    2
    FileOutputStream fos = new FileOutputStream("File_Name", true);
    fos.write(data);

    true允许将数据附加到现有文件中。如果我们会写

    1
    FileOutputStream fos = new FileOutputStream("File_Name");

    它将覆盖现有文件。所以去第一个方法。

    你也可以试试这个：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    JFileChooser c= new JFileChooser();
    c.showOpenDialog(c);
    File write_file = c.getSelectedFile();
    String Content ="Writing into file"; //what u would like to append to the file



    try
    {
        RandomAccessFile raf = new RandomAccessFile(write_file,"rw");
        long length = raf.length();
        //System.out.println(length);
        raf.setLength(length + 1); //+ (integer value) for spacing
        raf.seek(raf.length());
        raf.writeBytes(Content);
        raf.close();
    }
    catch (Exception e) {
        //any exception handling method of ur choice
    }

    以下方法让您将文本追加到某个文件：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    private void appendToFile(String filePath, String text)
    {
        PrintWriter fileWriter = null;

        try
        {
            fileWriter = new PrintWriter(new BufferedWriter(new FileWriter(
                    filePath, true)));

            fileWriter.println(text);
        } catch (IOException ioException)
        {
            ioException.printStackTrace();
        } finally
        {
            if (fileWriter != null)
            {
                fileWriter.close();
            }
        }
    }

    或者使用FileUtils：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public static void appendToFile(String filePath, String text) throws IOException
    {
        File file = new File(filePath);

        if(!file.exists())
        {
            file.createNewFile();
        }

        String fileContents = FileUtils.readFileToString(file);

        if(file.length() != 0)
        {
            fileContents = fileContents.concat(System.lineSeparator());
        }

        fileContents = fileContents.concat(text);

        FileUtils.writeStringToFile(file, fileContents);
    }

    效率不高但工作正常。正确处理换行符并创建一个新文件(如果尚未存在)。

    我可能会建议apache commons项目。该项目已经提供了一个框架，可以满足您的需求(即灵活过滤集合)。

    此代码将满足您的需求：

    1
    2
    3
       FileWriter fw=new FileWriter("C:\\file.json",true);
       fw.write("ssssss");
       fw.close();
    相关讨论

    如果您想在特定线路中添加某些文本，您可以先读取整个文件，在任意位置附加文本，然后覆盖以下代码中的所有内容：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    public static void addDatatoFile(String data1, String data2){


        String fullPath ="/home/user/dir/file.csv";

        File dir = new File(fullPath);
        List<String> l = new LinkedList<String>();

        try (BufferedReader br = new BufferedReader(new FileReader(dir))) {
            String line;
            int count = 0;

            while ((line = br.readLine()) != null) {
                if(count == 1){
                    //add data at the end of second line                    
                    line += data1;
                }else if(count == 2){
                    //add other data at the end of third line
                    line += data2;
                }
                l.add(line);
                count++;
            }
            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }      
        createFileFromList(l, dir);
    }

    public static void createFileFromList(List<String> list, File f){

        PrintWriter writer;
        try {
            writer = new PrintWriter(f,"UTF-8");
            for (String d : list) {
                writer.println(d.toString());
            }
            writer.close();            
        } catch (FileNotFoundException | UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    我的答案：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    JFileChooser chooser= new JFileChooser();
    chooser.showOpenDialog(chooser);
    File file = chooser.getSelectedFile();
    String Content ="What you want to append to file";

    try
    {
        RandomAccessFile random = new RandomAccessFile(file,"rw");
        long length = random.length();
        random.setLength(length + 1);
        random.seek(random.length());
        random.writeBytes(Content);
        random.close();
    }
    catch (Exception exception) {
        //exception handling
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    /**********************************************************************
     * it will write content to a specified  file
     *
     * @param keyString
     * @throws IOException
     *********************************************************************/
    public static void writeToFile(String keyString,String textFilePAth) throws IOException {
        // For output to file
        File a = new File(textFilePAth);

        if (!a.exists()) {
            a.createNewFile();
        }
        FileWriter fw = new FileWriter(a.getAbsoluteFile(), true);
        BufferedWriter bw = new BufferedWriter(fw);
        bw.append(keyString);
        bw.newLine();
        bw.close();
    }// end of writeToFile()

    1.7方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    void appendToFile(String filePath, String content) throws IOException{

        Path path = Paths.get(filePath);

        try (BufferedWriter writer =
                Files.newBufferedWriter(path,
                        StandardOpenOption.APPEND)) {
            writer.newLine();
            writer.append(content);
        }

        /*
        //Alternative:
        try (BufferedWriter bWriter =
                Files.newBufferedWriter(path,
                        StandardOpenOption.WRITE, StandardOpenOption.APPEND);
                PrintWriter pWriter = new PrintWriter(bWriter)
                ) {
            pWriter.println();//to have println() style instead of newLine();  
            pWriter.append(content);//Also, bWriter.append(content);
        }*/
    }

    您可以使用follong代码将内容附加到文件中：

    1
    2
    3
    4
    5
    6
    7
     String fileName="/home/shriram/Desktop/Images/"+"test.txt";
      FileWriter fw=new FileWriter(fileName,true);    
      fw.write("here will be you content to insert or append in file");    
      fw.close();
      FileWriter fw1=new FileWriter(fileName,true);    
     fw1.write("another content will be here to be append in the same file");    
     fw1.close();