Cách nối văn bản vào tệp hiện có trong Java

Tôi cần nối thêm văn bản nhiều lần vào một tệp hiện có trong Java. Làm thế nào để làm điều đó?

Bạn đang làm điều này cho mục đích đăng nhập? Nếu vậy có một số thư viện cho việc này . Hai trong số phổ biến nhất là Log4j và Logback .

Java 7+

Nếu bạn chỉ cần làm điều này một lần, lớp Tệp sẽ làm điều này dễ dàng:

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

^{Cẩn thận : Cách tiếp cận trên sẽ đưa ra NoSuchFileExceptionnếu tập tin chưa tồn tại. Nó cũng không tự động thêm một dòng mới (mà bạn thường muốn khi thêm vào một tệp văn bản). Câu trả lời của Steve Chambers bao gồm cách bạn có thể làm điều này với Fileslớp học.}

Tuy nhiên, nếu bạn sẽ ghi vào cùng một tệp nhiều lần, thì ở trên phải mở và đóng tệp trên đĩa nhiều lần, đó là một hoạt động chậm. Trong trường hợp này, một nhà văn đệm là tốt hơn:

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
}

Ghi chú:

• Tham số thứ hai cho hàm FileWritertạo sẽ yêu cầu nó nối vào tệp, thay vì viết một tệp mới. (Nếu tệp không tồn tại, nó sẽ được tạo.)
• Sử dụng một BufferedWriterđược khuyến nghị cho một nhà văn đắt tiền (chẳng hạn nhưFileWriter ).
• Sử dụng PrintWritercho phép bạn truy cập vào printlncú pháp mà có lẽ bạn đã quen sử dụng System.out.
• Nhưng BufferedWritervà PrintWritergiấy gói là không thực sự cần thiết.

Java cũ hơn

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
}

Xử lý ngoại lệ

Nếu bạn cần xử lý ngoại lệ mạnh mẽ cho Java cũ hơn, nó sẽ rất dài dòng:

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

Bạn có thể sử dụng fileWritervới một cờ được đặt thành true, để nối thêm.

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

Không phải tất cả các câu trả lời ở đây với các khối thử / bắt có các phần .close () có trong một khối cuối cùng không?

Ví dụ cho câu trả lời được đánh dấu:

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

Ngoài ra, kể từ Java 7, bạn có thể sử dụng câu lệnh try-with-resource . Không có khối cuối cùng được yêu cầu để đóng (các) tài nguyên được khai báo vì nó được xử lý tự động và cũng ít dài dòng hơn:

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

Chỉnh sửa - kể từ Apache Commons 2.1, cách chính xác để làm điều đó là:

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

Tôi đã điều chỉnh giải pháp của @ Kip để bao gồm việc đóng tệp đúng cách vào cuối cùng:

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

Để mở rộng một chút về câu trả lời của Kip , đây là một phương pháp Java 7+ đơn giản để nối một dòng mới vào một tệp, tạo nó nếu nó chưa tồn tại :

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

Lưu ý: Ở trên sử dụng Files.writequá tải ghi các dòng văn bản vào một tệp (tức là tương tự như một printlnlệnh). Để chỉ viết văn bản đến cuối (nghĩa là tương tự printlệnh), Files.writecó thể sử dụng quá tải thay thế , chuyển qua một mảng byte (ví dụ "mytext".getBytes(StandardCharsets.UTF_8)).

Hãy chắc chắn rằng luồng được đóng đúng trong tất cả các kịch bản.

Có một chút đáng báo động là có bao nhiêu câu trả lời trong số này để mở tệp xử lý trong trường hợp có lỗi. Câu trả lời https://stackoverflow.com/a/15053443/2498188 là về tiền nhưng chỉ vì BufferedWriter()không thể ném. Nếu nó có thể thì một ngoại lệ sẽ để FileWriterđối tượng mở.

Một cách tổng quát hơn để làm điều này mà không quan tâm nếu BufferedWriter()có thể ném:

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

Biên tập:

Kể từ Java 7, cách được đề xuất là sử dụng "thử với tài nguyên" và để JVM xử lý:

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

Trong Java-7 cũng có thể được thực hiện như vậy:

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

java 7+

Theo ý kiến ​​khiêm tốn của tôi vì tôi là người hâm mộ java đơn giản, tôi sẽ đề xuất một cái gì đó rằng đó là sự kết hợp của các câu trả lời đã nói ở trên. Có lẽ tôi đến trễ bữa tiệc. Đây là mã:

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

Nếu tệp không tồn tại, nó sẽ tạo ra nó và nếu đã tồn tại, nó sẽ nối thêm mẫu vào tệp hiện có. Sử dụng điều này, giúp bạn tiết kiệm từ việc thêm các lib không cần thiết vào đường dẫn lớp của bạn.

Điều này có thể được thực hiện trong một dòng mã. Hi vọng điêu nay co ich :)

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

Sử dụng java.nio. Các tệp cùng với 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();

Điều này tạo ra một BufferedWriterTệp sử dụng, chấp nhận StandardOpenOptioncác tham số và tự động xóa PrintWritertừ kết quả BufferedWriter. PrintWriter's println()phương pháp, sau đó có thể được gọi để ghi vào tập tin.

Các StandardOpenOptiontham số được sử dụng trong mã này: mở tệp để ghi, chỉ nối thêm vào tệp và tạo tệp nếu nó không tồn tại.

Paths.get("path here")có thể được thay thế bằng new File("path here").toPath(). Và Charset.forName("charset name")có thể được sửa đổi để phù hợp với mong muốn Charset.

Tôi chỉ thêm chi tiết nhỏ:

    new FileWriter("outfilename", true)

2.nd tham số (true) là một tính năng (hoặc, giao diện) được gọi là appendable ( http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html ). Nó có trách nhiệm có thể thêm một số nội dung vào cuối tập tin / luồng cụ thể. Giao diện này được triển khai từ Java 1.5. Mỗi đối tượng (ví dụ BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer ) với giao diện này có thể được sử dụng để thêm nội dung

Nói cách khác, bạn có thể thêm một số nội dung vào tệp được nén hoặc một số quy trình http

Mẫu, sử dụng ổi:

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

Hãy thử với bufferFileWriter.append, nó hoạt động với tôi.

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

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

điều này sẽ làm những gì bạn dự định ..

Tốt hơn là sử dụng tài nguyên dùng thử với tất cả những gì tiền java 7 cuối cùng cũng kinh doanh

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

Nếu chúng tôi đang sử dụng Java 7 trở lên và cũng biết nội dung sẽ được thêm (nối thêm) vào tệp, chúng tôi có thể sử dụng phương thức newBufferedWriter trong gói NIO.

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

Có một vài điểm cần lưu ý:

1. Luôn luôn là một thói quen tốt để chỉ định mã hóa bộ ký tự và chúng ta có hằng số trong lớp StandardCharsets.
2. Mã sử ​​dụng try-with-resourcecâu lệnh trong đó tài nguyên được tự động đóng sau khi thử.

Mặc dù OP chưa hỏi nhưng chỉ trong trường hợp chúng tôi muốn tìm kiếm các dòng có một số từ khóa cụ thể, ví dụ: confidentialchúng tôi có thể sử dụng API luồng trong Java:

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

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

đúng cho phép nối thêm dữ liệu trong tệp hiện có. Nếu chúng ta sẽ viết

FileOutputStream fos = new FileOutputStream("File_Name");

Nó sẽ ghi đè lên tập tin hiện có. Vì vậy, đi cho cách tiếp cận đầu tiên.

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

    }

}

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

    stream.write(

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

    );

} finally {
    stream.close();
}

Sau đó bắt một IOException ở đâu đó ngược dòng.

Tạo một chức năng bất cứ nơi nào trong dự án của bạn và chỉ cần gọi chức năng đó bất cứ khi nào bạn cần nó.

Các bạn phải nhớ rằng các bạn đang gọi các chủ đề đang hoạt động mà bạn không gọi không đồng bộ và vì đó có thể là 5 đến 10 trang tốt để thực hiện đúng. Tại sao không dành nhiều thời gian hơn cho dự án của bạn và quên đi việc viết bất cứ điều gì đã được viết. Đúng

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

ba dòng mã hai thực sự kể từ lần thứ ba thực sự nối thêm văn bản. : P

Thư viện

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

Mã

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

Bạn cũng có thể thử điều này:

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
}

Tôi có thể đề nghị dự án apache commons . Dự án này đã cung cấp một khung để làm những gì bạn cần (nghĩa là lọc linh hoạt các bộ sưu tập).

Phương pháp sau đây cho phép bạn thêm văn bản vào một số tệp:

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

Cách khác là sử dụng 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);
}

Nó không hiệu quả nhưng hoạt động tốt. Ngắt dòng được xử lý chính xác và một tệp mới được tạo nếu chưa tồn tại.

Mã này sẽ đáp ứng nhu cầu của bạn:

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

Trong trường hợp bạn muốn THÊM MỘT SỐ VĂN BẢN TRONG DÒNG ĐẶC BIỆT, trước tiên bạn có thể đọc toàn bộ tệp, nối thêm văn bản bất cứ nơi nào bạn muốn và sau đó ghi đè lên mọi thứ như trong mã dưới đây:

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

Câu trả lời của tôi:

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
}

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

Bạn có thể sử dụng mã follong để nối thêm nội dung trong tệp:

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

1.7 Cách tiếp cận:

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