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

D

Dave Jarvis

你这样做是为了记录目的吗？如果是，则有 several libraries for this。最流行的两个是 Log4j 和 Logback。

Java 7+

对于一次性任务，Files class 使这变得简单：

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。它也不会自动附加换行符（在附加到文本文件时通常需要）。另一种方法是同时传递 CREATE 和 APPEND 选项，如果文件尚不存在，它将首先创建文件：

private void write(final String s) throws IOException {
    Files.writeString(
        Path.of(System.getProperty("java.io.tmpdir"), "filename.txt"),
        s + System.lineSeparator(),
        CREATE, APPEND
    );
}

但是，如果您将多次写入同一个文件，则上述代码段必须多次打开和关闭磁盘上的文件，这是一个缓慢的操作。在这种情况下，BufferedWriter 更快：

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

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 进行强大的异常处理，它会变得非常冗长：

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
    }
}

您应该使用 java7 try-with-resources 或将 close() 放在 finally 块中，以确保在出现异常时关闭文件

让我们假设 new BufferedWriter(...) 抛出异常； FileWriter 会关闭吗？我猜它不会被关闭，因为 close() 方法（在正常情况下）将在 out 对象上调用，在这种情况下不会初始化 - 所以实际上不会调用 close() 方法->该文件将被打开，但不会被关闭。所以恕我直言，try 语句应该看起来像这样 try(FileWriter fw = new FileWriter("myFile.txt")){ Print writer = new ....//code goes here } 并且他应该在退出 try 块之前flush() 编写器！！！

注意，如果在 try 块内抛出异常，“Older java”示例将无法正确关闭流。

Java 7 方法有几个可能的“陷阱”： (1) 如果文件不存在，StandardOpenOption.APPEND 不会创建它——有点像静默失败，因为它也不会抛出异常。 (2) 使用 .getBytes() 意味着在附加文本之前或之后没有返回字符。已添加 alternative answer 来解决这些问题。

@SteveChambers 感谢您的意见。如果文件不存在，我无法相信附加模式不会创建文件，所以我不得不尝试确认。不知道他们在想什么...我发现它确实会引发异常，但是如果您复制/粘贴我的代码并将 catch 块留空，那么您就看不到它。我已更新我的答案以反映这些问题，并添加了指向您答案的链接。

e

eRaisedToX

您可以将 fileWriter 与设置为 true 的标志一起使用，以进行追加。

try
{
    String filename= "MyFile.txt";
    FileWriter fw = new FileWriter(filename,true); //the true will append the new data
    fw.write("add a line\n");//appends the string to the file
    fw.close();
}
catch(IOException ioe)
{
    System.err.println("IOException: " + ioe.getMessage());
}

close 应该放在 finally 块中，就像在 @etech's answer 中显示的那样，以防在创建 FileWriter 和调用 close 之间引发异常。

很好的答案，尽管使用 System.getProperty("line.separator") 代替"\n" 更好。

@Decoded 我已经回滚了你对这个答案的编辑，因为它没有编译。

@Kip，有什么问题？我一定输入了一个“错字”。

试试资源怎么样？ try(FileWriter fw = new FileWriter(filename,true)){ // Whatever }catch(IOException ex){ ex.printStackTrace(); }

d

deHaar

这里的所有 try/catch 块的答案不应该都包含在 finally 块中的 .close() 片段吗？

标记答案的示例：

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 statement。关闭声明的资源不需要 finally 块，因为它是自动处理的，而且也不那么冗长：

try(PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)))) {
    out.println("the text");
} catch (IOException e) {
    System.err.println(e);
}

当 out 超出范围时，它会在被垃圾收集时自动关闭，对吗？在您使用 finally 块的示例中，如果我没记错的话，我认为您实际上需要另一个嵌套的 try/catch 围绕 out.close()。 Java 7 解决方案非常巧妙！（自 Java 6 以来我没有做过任何 Java 开发，所以我不熟悉这种变化。）

@Kip不，超出范围在Java中没有任何作用。该文件将在未来的某个随机时间关闭。（可能在程序关闭时）

@etech 第二种方法是否需要 flush 方法？

S

Sridhar Sarnobat

使用 Apache Commons 2.1：

import org.apache.logging.log4j.core.util.FileUtils;

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

哦谢谢。我被所有其他答案的复杂性逗乐了。我真的不明白为什么人们喜欢使他们的（开发人员）生活复杂化。

这种方法的问题在于它每次都会打开和关闭输出流。根据您写入文件的内容和频率，这可能会导致可笑的开销。

@Buffalo 是对的。但是在将它们写入文件之前，您始终可以使用 StringBuilder 构建大块（值得编写）。

@KonstantinK，但是您需要编写的所有内容都会加载到内存中。

S

Steve Chambers

稍微扩展一下 Kip's answer，这是一个简单的 Java 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 命令）。要只将文本写入末尾（即类似于打印命令），可以使用替代的 Files.write 重载，传入一个字节数组（例如“mytext”.getBytes(StandardCharsets.UTF_8)）。 CREATE 选项仅在指定目录已存在时才有效 - 如果不存在，则抛出 NoSuchFileException。如果需要，可以在设置路径后添加以下代码来创建目录结构： Path pathParent = path.getParent(); if (!Files.exists(pathParent)) { Files.createDirectories(pathParent); }

你需要检查文件是否存在吗？我认为.CREATE可以为您完成这项工作。

如果在文件已经存在时使用 .CREATE，它会默默地无法追加任何内容 - 不会引发异常，但现有文件内容保持不变。

使用 APPEND + CREATE 效果很好，无需检查：

Files.write(Paths.get("test.log"), (Instant.now().toString() + "\r\n").getBytes(), StandardOpenOption.CREATE, StandardOpenOption.APPEND);

C

Community

确保流在所有情况下都正确关闭。

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

一种更通用的方法，它不关心 BufferedWriter() 是否可以抛出：

  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 处理它：

  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.
  }

+1 表示正确的 ARM 与 Java 7。这是关于这个棘手主题的好问题：stackoverflow.com/questions/12552863/…。

嗯，由于某种原因，PrintWriter.close() 未在 the docs 中声明为 throws IOException。查看它的 source，close() 方法确实不能抛出 IOException，因为它从底层流中捕获它，并设置一个标志。因此，如果您正在编写下一代航天飞机或 X 射线剂量测量系统的代码，则应在尝试 out.close() 后使用 PrintWriter.checkError()。这确实应该记录在案。

如果我们对关闭过于偏执，那么每个 XX.close() 都应该在自己的 try/catch 中，对吗？例如，out.close() 可能会引发异常，在这种情况下，bw.close() 和 fw.close() 将永远不会被调用，而 fw 是最关键的关闭。

T

Tsolak Barseghyan

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

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

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

Path filePath = Paths.get("someFile.txt");
if (!Files.exists(filePath)) {
    Files.createFile(filePath);
}
Files.write(filePath, "Text to be added".getBytes(), StandardOpenOption.APPEND);

需要进口什么？这些东西使用哪个库？

L

Lefteris Bab

爪哇 7+

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

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

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

R

Rahbee Alvee

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

Files.write(Paths.get(fileName), msg.getBytes(), StandardOpenOption.APPEND);

它可能还不够:) 更好的版本是 Files.write(Paths.get(fileName), msg.getBytes(), StandardOpenOption.APPEND, StandardOpenOption.CREATE);

x

xhudik

我只是添加一些小细节：

    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 进程

i

icasdri

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

    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();

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

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

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

d

dantuch

示例，使用番石榴：

File to = new File("C:/test/test.csv");

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

这是一个可怕的建议。您打开文件的流 42 次而不是一次。

@xehpuk 好吧，这取决于。 42 仍然可以，如果它使代码更具可读性。 42k 是不能接受的。

a

ahajib

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

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

FileOutputStream fos = new FileOutputStream("File_Name");

它将覆盖现有文件。所以选择第一种方法。

a

ahajib

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

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);
}

这里的 obj.toJSONString() 是什么？

@BhaskaraArani 这只是一个字符串，他举了一个将 JSON 对象转换为字符串的示例，但想法是它可以是任何字符串。

D

David Charles

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.
        }

    }

}

以上只是提出的解决方案 At this link 的一个快速示例实现。因此，您可以复制并运行代码并立即查看它是如何工作的，请确保 output.out 文件与 Writer.java 文件位于同一目录中

B

Benjamin Varghese

    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();         
    }

这将做你想要的..

a

aashima

你也可以试试这个：

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
}

m

mikeyreilly

最好使用 try-with-resources 然后所有 pre-java 7 最终业务

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();
    }
}

a

akhil_mittal

如果我们使用 Java 7 及以上版本并且知道要添加（附加）到文件中的内容，我们可以使用 NIO 包中的 newBufferedWriter 方法。

public static void main(String[] args) {
    Path FILE_PATH = Paths.get("C:/temp", "temp.txt");
    String text = "\n 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();
    }
}

有几点需要注意：

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

虽然 OP 没有询问，但如果我们想搜索具有某些特定关键字的行，例如 confidential，我们可以在 Java 中使用流 API：

//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();
}

警告：使用 BufferedWriter write(String string) 时，如果希望在每个字符串写入后换行，则应调用 newLine()

S

SharkAlley

FileOutputStream stream = new FileOutputStream(path, true);
try {

    stream.write(

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

    );

} finally {
    stream.close();
}

然后在上游某处捕获 IOException。

N

Netcfmx

在项目的任何地方创建一个函数，然后在需要的地方调用该函数。

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

    //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

a

abSiddique

图书馆

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

代码

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);
    }
}

T

Tom Drake

我可能会建议 apache commons project。这个项目已经提供了一个框架来做你需要的（即灵活的集合过滤）。

B

BullyWiiPlaza

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

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：

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);
}

它效率不高，但工作正常。换行符被正确处理，如果一个新文件尚不存在，则会创建一个新文件。

A

APC

此代码将满足您的需求：

   FileWriter fw=new FileWriter("C:\\file.json",true);
   fw.write("ssssss");
   fw.close();

嗯……什么？？这将覆盖文件。

docs.oracle.com/javase/7/docs/api/java/io/…

l

lfvv

如果您想在特定行中添加一些文本，您可以首先阅读整个文件，将文本附加到您想要的任何位置，然后覆盖下面代码中的所有内容：

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();
    }
}

u

userAsh

我的答案：

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
}

M

Mihir Patel

/**********************************************************************
 * 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()

S

Saikat

对于 JDK 版本 >= 7

您可以利用这个简单的方法将给定的内容附加到指定的文件：

void appendToFile(String filePath, String content) {
  try (FileWriter fw = new FileWriter(filePath, true)) {
    fw.write(content + System.lineSeparator());
  } catch (IOException e) { 
    // TODO handle exception
  }
}

我们正在附加模式下构造一个 FileWriter 对象。

B

BartoszKP

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

 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();

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

关注公众号

想领先一步获取最新的外包任务吗？

相似问题

平台

支持

联系我们