java写入文件不覆盖写入_Java写入文件–用Java写入文件的4种方法

java写入文件不覆盖写入

Java provides several ways to write to file. We can use FileWriter, BufferedWriter, java 7 Files and FileOutputStream to write a file in Java.

Java提供了几种写入文件的方法。 我们可以使用FileWriter ， BufferedWriter ，java 7 Files和FileOutputStream用Java编写文件。

Java写入文件 (Java Write to File)

Let’s have a brief look at four options we have for java write to file operation.

让我们简要地看一下java写入文件操作的四个选项。

1. FileWriter: FileWriter is the simplest way to write a file in Java. It provides overloaded write method to write int, byte array, and String to the File. You can also write part of the String or byte array using FileWriter. FileWriter writes directly into Files and should be used only when the number of writes is less.
   FileWriter ：FileWriter是用Java编写文件的最简单方法。 它提供了重载的write方法，可以将int，字节数组和String写入File。 您也可以使用FileWriter编写String或byte数组的一部分。 FileWriter直接写入文件，仅在写入次数较少时才应使用。
2. BufferedWriter: BufferedWriter is almost similar to FileWriter but it uses internal buffer to write data into File. So if the number of write operations is more, the actual IO operations are less and performance is better. You should use BufferedWriter when the number of write operations is more.
   BufferedWriter ：BufferedWriter与FileWriter几乎相似，但是它使用内部缓冲区将数据写入File。 因此，如果写入操作的数量更多，则实际的IO操作会更少，而性能会更好。 当写入操作的数量更多时，应使用BufferedWriter。
3. FileOutputStream: FileWriter and BufferedWriter are meant to write text to the file but when you need raw stream data to be written into file, you should use FileOutputStream to write file in java.
   FileOutputStream ：FileWriter和BufferedWriter旨在将文本写入文件，但是当您需要将原始流数据写入文件时，应使用FileOutputStream在Java中写入文件。
4. Files: Java 7 introduced Files utility class and we can write a file using its write function. Internally it’s using OutputStream to write byte array into file.
   Files ：Java 7引入了Files实用程序类，我们可以使用其write函数编写文件。 在内部，它使用OutputStream将字节数组写入文件。

Java写入文件示例 (Java Write to File Example)

Here is the example showing how we can write a file in java using FileWriter, BufferedWriter, FileOutputStream, and Files in java.

这是显示如何在Java中使用FileWriter，BufferedWriter，FileOutputStream和Files编写文件的示例。

WriteFile.java

WriteFile.java

package com.journaldev.files;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Paths;

public class WriteFile {

    /**
     * This class shows how to write file in java
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) {
        String data = "I will write this String to File in Java";
        int noOfLines = 10000;
        writeUsingFileWriter(data);
        
        writeUsingBufferedWriter(data, noOfLines);
        
        writeUsingFiles(data);
        
        writeUsingOutputStream(data);
        System.out.println("DONE");
    }

    /**
     * Use Streams when you are dealing with raw data
     * @param data
     */
    private static void writeUsingOutputStream(String data) {
        OutputStream os = null;
        try {
            os = new FileOutputStream(new File("/Users/pankaj/os.txt"));
            os.write(data.getBytes(), 0, data.length());
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * Use Files class from Java 1.7 to write files, internally uses OutputStream
     * @param data
     */
    private static void writeUsingFiles(String data) {
        try {
            Files.write(Paths.get("/Users/pankaj/files.txt"), data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Use BufferedWriter when number of write operations are more
     * It uses internal buffer to reduce real IO operations and saves time
     * @param data
     * @param noOfLines
     */
    private static void writeUsingBufferedWriter(String data, int noOfLines) {
        File file = new File("/Users/pankaj/BufferedWriter.txt");
        FileWriter fr = null;
        BufferedWriter br = null;
        String dataWithNewLine=data+System.getProperty("line.separator");
        try{
            fr = new FileWriter(file);
            br = new BufferedWriter(fr);
            for(int i = noOfLines; i>0; i--){
                br.write(dataWithNewLine);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                br.close();
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Use FileWriter when number of write operations are less
     * @param data
     */
    private static void writeUsingFileWriter(String data) {
        File file = new File("/Users/pankaj/FileWriter.txt");
        FileWriter fr = null;
        try {
            fr = new FileWriter(file);
            fr.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //close resources
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

These are the standard methods to write a file in java and you should choose any one of these based on your project requirements. That’s all for Java write to file example.

这些是用Java编写文件的标准方法，您应根据项目要求选择其中一种。 这就是Java写入文件示例的全部内容。

GitHub Repository. GitHub存储库中签出更多Java IO示例。

翻译自: https://www.journaldev.com/878/java-write-to-file

java写入文件不覆盖写入