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

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

1182090 次浏览
小开
最佳答案

您这样做是为了记录目的吗？如果是这样，有几个图书馆为此。两个最流行的是Log4j和登录。

Java7+

对于一次性任务，文件类可以轻松完成：

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可以让您访问println语法，您可能已经习惯了System.out。
  • 但是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
}
}
小开

您可以使用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());
}
小开

使用Apache Commons 2.1：

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


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

我只是补充一些小细节：

    new FileWriter("outfilename", true)

2.nd参数（true）是一个名为附录（http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html）的特性（或接口）。它负责能够将一些内容添加到特定文件/流的末尾。此接口自Java1.5开始实现。具有此接口的每个对象（即BufferedWriter， CharArrayWriter， CharBuffer， FileWriter， FilterWriter， LogStream， Output StreamWriter， PipeedWriter， PrintStream， PrintWriter， StringBuffer， StringBuilder， StringWriter， Writer）都可用于添加内容

换句话说，您可以将一些内容添加到gzip文件或一些超文本传输协议过程中

小开 
    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/catch块的答案都不应该包含在最后一个块中的.关闭（）部分吗？

标记答案示例：

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

此外，从Java7开始，您可以使用使用资源尝试语句。关闭声明的资源不需要最终块，因为它是自动处理的，也不那么冗长：

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

示例，使用Guava：

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);
}
小开 
FileOutputStream stream = new FileOutputStream(path, true);
try {


stream.write(


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


);


} finally {
stream.close();
}

然后在上游某处捕获IOException。

小开

使用java.nio.文件和java.nio.file.自定义选项

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

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

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

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

小开

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

小开

确保流在所有场景中都正确关闭。

这些答案中有多少在出现错误时将文件句柄打开，这有点令人担忧。答案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
}
}

编辑：

从Java7开始，推荐的方法是使用“使用资源尝试”并让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.
}
小开

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

伙计们，你们必须记住，你们正在调用那些不是异步调用的活动线程，因为它可能需要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

小开

图书馆

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

你也可以试试这个：

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

更好地使用try with资源，然后使用所有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();
}
}
小开

在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);
小开

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

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

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

小开

试试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);
}
小开

如果我们使用Java7及以上，并且也知道要添加（附加）到文件中的内容，我们可以使用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();
}
}

有几点需要注意：

  1. 指定字符集编码总是一个好习惯，为此我们在类StandardCharsets中有一个常量。
  2. 该代码使用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();
}
小开

我的回答：

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

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

Files.write(Paths.get(fileName), msg.getBytes(), StandardOpenOption.APPEND);
小开 
FileOutputStream fos = new FileOutputStream("File_Name", true);
fos.write(data);

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

FileOutputStream fos = new FileOutputStream("File_Name");

它将覆盖现有文件。所以请使用第一种方法。

小开

此代码将满足您的需求：

   FileWriter fw=new FileWriter("C:\\file.json",true);
fw.write("ssssss");
fw.close();
小开 
/**********************************************************************
* 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()
小开

如果你想在特定行中添加一些文本，你可以先读取整个文件，在任何地方附加文本，然后像下面的代码一样覆盖所有内容：

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


}


}
小开

稍微扩展Kip的回答， 这是一个简单的Java7+方法，可以将新线附加到文件如果它不存在，则创建它：

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

进一步说明：

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

  2. CREATE选项仅在指定的目录已经存在时才有效-如果不存在，则抛出NoSuchFileException。如果需要，可以在设置path后添加以下代码以创建目录结构：

    Path pathParent = path.getParent();
if (!Files.exists(pathParent)) {
Files.createDirectories(pathParent);
}
小开

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

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

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

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

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

小开

1.7方法：

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);
}*/
}
小开

对于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对象。


提交答案