Làm cách nào để tạo một tệp và ghi vào tệp đó bằng Java?

Cách đơn giản nhất để tạo và ghi vào tệp (văn bản) trong Java là gì?

Lưu ý rằng mỗi mẫu mã dưới đây có thể ném IOException. Các khối thử / bắt / cuối cùng đã bị bỏ qua cho ngắn gọn. Xem hướng dẫn này để biết thông tin về xử lý ngoại lệ.

Lưu ý rằng mỗi mẫu mã dưới đây sẽ ghi đè lên tệp nếu nó đã tồn tại

Tạo một tệp văn bản:

PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8");
writer.println("The first line");
writer.println("The second line");
writer.close();

Tạo một tệp nhị phân:

byte data[] = ...
FileOutputStream out = new FileOutputStream("the-file-name");
out.write(data);
out.close();

Người dùng Java 7+ có thể sử dụng Fileslớp để ghi vào các tệp:

Tạo một tệp văn bản:

List<String> lines = Arrays.asList("The first line", "The second line");
Path file = Paths.get("the-file-name.txt");
Files.write(file, lines, StandardCharsets.UTF_8);
//Files.write(file, lines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);

Tạo một tệp nhị phân:

byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);

Trong Java 7 trở lên:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(
              new FileOutputStream("filename.txt"), "utf-8"))) {
   writer.write("something");
}

Có những tiện ích hữu ích cho điều đó:

• FileUtils.writeStringtoFile (..) từ commons-io
• Files.write (..) từ ổi

Cũng lưu ý rằng bạn có thể sử dụng một FileWriter, nhưng nó sử dụng mã hóa mặc định, thường là một ý tưởng tồi - tốt nhất là chỉ định rõ ràng mã hóa.

Dưới đây là câu trả lời gốc, trước Java 7

Writer writer = null;

try {
    writer = new BufferedWriter(new OutputStreamWriter(
          new FileOutputStream("filename.txt"), "utf-8"));
    writer.write("Something");
} catch (IOException ex) {
    // Report
} finally {
   try {writer.close();} catch (Exception ex) {/*ignore*/}
}

Xem thêm: Đọc, viết và tạo tệp (bao gồm NIO2).

Nếu bạn đã có nội dung bạn muốn ghi vào tệp (và không được tạo nhanh chóng), việc java.nio.file.Filesbổ sung trong Java 7 như một phần của I / O gốc cung cấp cách đơn giản và hiệu quả nhất để đạt được mục tiêu của bạn.

Về cơ bản việc tạo và ghi vào một tệp chỉ là một dòng, hơn nữa chỉ là một cuộc gọi phương thức đơn giản !

Ví dụ sau đây tạo và ghi vào 6 tệp khác nhau để giới thiệu cách sử dụng tệp này:

Charset utf8 = StandardCharsets.UTF_8;
List<String> lines = Arrays.asList("1st line", "2nd line");
byte[] data = {1, 2, 3, 4, 5};

try {
    Files.write(Paths.get("file1.bin"), data);
    Files.write(Paths.get("file2.bin"), data,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
    Files.write(Paths.get("file3.txt"), "content".getBytes());
    Files.write(Paths.get("file4.txt"), "content".getBytes(utf8));
    Files.write(Paths.get("file5.txt"), lines, utf8);
    Files.write(Paths.get("file6.txt"), lines, utf8,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
} catch (IOException e) {
    e.printStackTrace();
}

public class Program {
    public static void main(String[] args) {
        String text = "Hello world";
        BufferedWriter output = null;
        try {
            File file = new File("example.txt");
            output = new BufferedWriter(new FileWriter(file));
            output.write(text);
        } catch ( IOException e ) {
            e.printStackTrace();
        } finally {
          if ( output != null ) {
            output.close();
          }
        }
    }
}

Đây là một chương trình ví dụ nhỏ để tạo hoặc ghi đè lên một tệp. Đây là phiên bản dài để có thể hiểu dễ dàng hơn.

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class writer {
    public void writing() {
        try {
            //Whatever the file path is.
            File statText = new File("E:/Java/Reference/bin/images/statsTest.txt");
            FileOutputStream is = new FileOutputStream(statText);
            OutputStreamWriter osw = new OutputStreamWriter(is);    
            Writer w = new BufferedWriter(osw);
            w.write("POTATO!!!");
            w.close();
        } catch (IOException e) {
            System.err.println("Problem writing to the file statsTest.txt");
        }
    }

    public static void main(String[]args) {
        writer write = new writer();
        write.writing();
    }
}

Một cách rất đơn giản để tạo và ghi vào một tệp trong Java:

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

public class CreateFiles {

    public static void main(String[] args) {
        try{
            // Create new file
            String content = "This is the content to write into create file";
            String path="D:\\a\\hi.txt";
            File file = new File(path);

            // If file doesn't exists, then create it
            if (!file.exists()) {
                file.createNewFile();
            }

            FileWriter fw = new FileWriter(file.getAbsoluteFile());
            BufferedWriter bw = new BufferedWriter(fw);

            // Write in file
            bw.write(content);

            // Close connection
            bw.close();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
}

Sử dụng:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) {
    writer.write("text to write");
} 
catch (IOException ex) {
    // Handle me
}  

Sử dụng try() sẽ đóng luồng tự động. Phiên bản này ngắn, nhanh (được đệm) và cho phép chọn mã hóa.

Tính năng này đã được giới thiệu trong Java 7.

Ở đây chúng tôi đang nhập một chuỗi vào một tệp văn bản:

String content = "This is the content to write into a file";
File file = new File("filename.txt");
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close(); // Be sure to close BufferedWriter

Chúng ta có thể dễ dàng tạo một tệp mới và thêm nội dung vào đó.

Do tác giả không chỉ định liệu họ có yêu cầu giải pháp cho các phiên bản Java đã được EoL'd (bởi cả Sun và IBM hay không và đây là những JVM phổ biến nhất về mặt kỹ thuật) và do hầu hết mọi người dường như đã trả lời Câu hỏi của tác giả trước khi được chỉ định rằng đó là một tệp văn bản (không phải nhị phân) , tôi đã quyết định cung cấp câu trả lời của mình.

Trước hết, Java 6 nói chung đã hết tuổi thọ và do tác giả không chỉ định anh ta cần khả năng tương thích kế thừa, tôi đoán nó tự động có nghĩa là Java 7 trở lên (Java 7 chưa phải là EoL'd của IBM). Vì vậy, chúng ta có thể xem ngay tệp hướng dẫn I / O: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Trước khi phát hành Java SE 7, lớp java.io.File là cơ chế được sử dụng cho tệp I / O, nhưng nó có một số nhược điểm.

• Nhiều phương pháp đã không đưa ra ngoại lệ khi chúng thất bại, vì vậy không thể có được thông báo lỗi hữu ích. Ví dụ: nếu xóa tệp không thành công, chương trình sẽ nhận được "xóa thất bại" nhưng sẽ không biết có phải do tệp không tồn tại hay không, người dùng không có quyền hoặc có một số vấn đề khác.
• Phương thức đổi tên không hoạt động nhất quán trên các nền tảng.
• Không có hỗ trợ thực sự cho các liên kết tượng trưng.
• Cần hỗ trợ thêm cho siêu dữ liệu, như quyền tệp, chủ sở hữu tệp và các thuộc tính bảo mật khác. Truy cập siêu dữ liệu tập tin là không hiệu quả.
• Nhiều phương thức File không mở rộng được. Yêu cầu một danh sách thư mục lớn trên một máy chủ có thể dẫn đến treo. Các thư mục lớn cũng có thể gây ra sự cố tài nguyên bộ nhớ, dẫn đến việc từ chối dịch vụ.
• Không thể viết mã đáng tin cậy có thể đệ quy một cây tập tin và trả lời thích hợp nếu có các liên kết tượng trưng tròn.

Oh tốt, đó là quy tắc ra java.io.File. Nếu một tập tin không thể được viết / nối thêm, bạn thậm chí không thể biết tại sao.

Chúng ta có thể tiếp tục xem hướng dẫn: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Nếu bạn có tất cả các dòng bạn sẽ viết (chắp thêm) vào tệp văn bản trước , cách tiếp cận được đề xuất là https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# write-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption ...-

Dưới đây là một ví dụ (đơn giản hóa):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, StandardCharsets.UTF_8);

Một ví dụ khác (nối thêm):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);

Nếu bạn muốn viết nội dung tệp khi bạn đi : https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#newBufferedWriter-java.nio.file.Path-java .nio.charset.Charset-java.nio.file.OpenOption ...-

Ví dụ đơn giản hóa (Java 8 trở lên):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
    writer.append("Zero header: ").append('0').write("\r\n");
    [...]
}

Một ví dụ khác (nối thêm):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) {
    writer.write("----------");
    [...]
}

Các phương pháp này đòi hỏi nỗ lực tối thiểu từ phía tác giả và nên được ưu tiên cho tất cả các phương pháp khác khi ghi vào tệp [văn bản].

Nếu bạn muốn có trải nghiệm tương đối không đau, bạn cũng có thể xem gói IO Commons IO , cụ thể hơn là FileUtilslớp .

Không bao giờ quên kiểm tra thư viện của bên thứ ba. Joda - Thời gian để thao tác ngày, Apache Commons LangStringUtils cho các hoạt động chuỗi phổ biến và như vậy có thể làm cho mã của bạn dễ đọc hơn.

Java là một ngôn ngữ tuyệt vời, nhưng thư viện tiêu chuẩn đôi khi hơi thấp. Mạnh mẽ, nhưng dù sao cũng ở cấp độ thấp.

Nếu bạn vì một lý do nào đó muốn tách biệt hành động tạo và viết, thì tương đương với Java touchlà

try {
   //create a file named "testfile.txt" in the current working directory
   File myFile = new File("testfile.txt");
   if ( myFile.createNewFile() ) {
      System.out.println("Success!");
   } else {
      System.out.println("Failure!");
   }
} catch ( IOException ioe ) { ioe.printStackTrace(); }

createNewFile()không kiểm tra sự tồn tại và tập tin tạo ra nguyên tử. Điều này có thể hữu ích nếu bạn muốn đảm bảo bạn là người tạo tệp trước khi ghi vào nó.

Dưới đây là một số cách có thể để tạo và viết một tệp trong Java:

Sử dụng FileOutputStream

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
  bw.write("Write somthing to the file ...");
  bw.newLine();
  bw.close();
} catch (FileNotFoundException e){
  // File was not found
  e.printStackTrace();
} catch (IOException e) {
  // Problem when writing to the file
  e.printStackTrace();
}

Sử dụng FileWriter

try {
  FileWriter fw = new FileWriter("myOutFile.txt");
  fw.write("Example of content");
  fw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Sử dụng PrintWriter

try {
  PrintWriter pw = new PrintWriter("myOutFile.txt");
  pw.write("Example of content");
  pw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Sử dụng OutputStreamWriter

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  osw.write("Soe content ...");
  osw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Để biết thêm kiểm tra hướng dẫn này về Cách đọc và ghi tệp trong Java .

Sử dụng:

JFileChooser c = new JFileChooser();
c.showOpenDialog(c);
File writeFile = c.getSelectedFile();
String content = "Input the data here to be written to your file";

try {
    FileWriter fw = new FileWriter(writeFile);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.append(content);
    bw.append("hiiiii");
    bw.close();
    fw.close();
}
catch (Exception exc) {
   System.out.println(exc);
}

Cách tốt nhất là sử dụng Java7: Java 7 giới thiệu một cách làm việc mới với hệ thống tệp, cùng với một lớp tiện ích mới - Tệp. Sử dụng lớp Tệp, chúng ta cũng có thể tạo, di chuyển, sao chép, xóa các tệp và thư mục; nó cũng có thể được sử dụng để đọc và ghi vào một tập tin.

public void saveDataInFile(String data) throws IOException {
    Path path = Paths.get(fileName);
    byte[] strToBytes = data.getBytes();

    Files.write(path, strToBytes);
}

Viết bằng FileChannel Nếu bạn đang xử lý các tệp lớn, FileChannel có thể nhanh hơn IO tiêu chuẩn. Đoạn mã sau ghi String vào một tệp bằng FileChannel:

public void saveDataInFile(String data) 
  throws IOException {
    RandomAccessFile stream = new RandomAccessFile(fileName, "rw");
    FileChannel channel = stream.getChannel();
    byte[] strBytes = data.getBytes();
    ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
    buffer.put(strBytes);
    buffer.flip();
    channel.write(buffer);
    stream.close();
    channel.close();
}

Viết bằng DataOutputStream

public void saveDataInFile(String data) throws IOException {
    FileOutputStream fos = new FileOutputStream(fileName);
    DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos));
    outStream.writeUTF(data);
    outStream.close();
}

Viết bằng FileOutputStream

Bây giờ chúng ta hãy xem làm thế nào chúng ta có thể sử dụng FileOutputStream để ghi dữ liệu nhị phân vào một tệp. Đoạn mã sau chuyển đổi một chuỗi int byte và ghi các byte vào tệp bằng FileOutputStream:

public void saveDataInFile(String data) throws IOException {
    FileOutputStream outputStream = new FileOutputStream(fileName);
    byte[] strToBytes = data.getBytes();
    outputStream.write(strToBytes);

    outputStream.close();
}

Viết bằng PrintWriter chúng ta có thể sử dụng PrintWriter để viết văn bản có định dạng vào một tệp:

public void saveDataInFile() throws IOException {
    FileWriter fileWriter = new FileWriter(fileName);
    PrintWriter printWriter = new PrintWriter(fileWriter);
    printWriter.print("Some String");
    printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000);
    printWriter.close();
}

Viết bằng BufferedWriter: sử dụng BufferedWriter để viết Chuỗi vào tệp mới:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
    writer.write(data);

    writer.close();
}

nối một chuỗi vào tệp hiện có:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
    writer.append(' ');
    writer.append(data);

    writer.close();
}

Tôi nghĩ rằng đây là cách ngắn nhất:

FileWriter fr = new FileWriter("your_file_name.txt"); // After '.' write
// your file extention (".txt" in this case)
fr.write("Things you want to write into the file"); // Warning: this will REPLACE your old file content!
fr.close();

Để tạo tập tin mà không ghi đè tập tin hiện có:

System.out.println("Choose folder to create file");
JFileChooser c = new JFileChooser();
c.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
c.showOpenDialog(c);
c.getSelectedFile();
f = c.getSelectedFile(); // File f - global variable
String newfile = f + "\\hi.doc";//.txt or .doc or .html
File file = new File(newfile);

try {
    //System.out.println(f);
    boolean flag = file.createNewFile();

    if(flag == true) {
        JOptionPane.showMessageDialog(rootPane, "File created successfully");
    }
    else {
        JOptionPane.showMessageDialog(rootPane, "File already exists");
    }
    /* Or use exists() function as follows:
        if(file.exists() == true) {
            JOptionPane.showMessageDialog(rootPane, "File already exists");
        }
        else {
            JOptionPane.showMessageDialog(rootPane, "File created successfully");
        }
    */
}
catch(Exception e) {
    // Any exception handling method of your choice
}

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

public class FileWriterExample {
    public static void main(String [] args) {
        FileWriter fw= null;
        File file =null;
        try {
            file=new File("WriteFile.txt");
            if(!file.exists()) {
                file.createNewFile();
            }
            fw = new FileWriter(file);
            fw.write("This is an string written to a file");
            fw.flush();
            fw.close();
            System.out.println("File written Succesfully");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package fileoperations;
import java.io.File;
import java.io.IOException;

public class SimpleFile {
    public static void main(String[] args) throws IOException {
        File file =new File("text.txt");
        file.createNewFile();
        System.out.println("File is created");
        FileWriter writer = new FileWriter(file);

        // Writes the content to the file
        writer.write("Enter the text that you want to write"); 
        writer.flush();
        writer.close();
        System.out.println("Data is entered into file");
    }
}

Chỉ một dòng thôi! pathvà linelà chuỗi

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

Files.write(Paths.get(path), lines.getBytes());

Cách đơn giản nhất tôi có thể tìm thấy:

Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
    writer.write("Hello, world!");
}

Nó có thể sẽ chỉ hoạt động cho 1.7+.

Rất đáng để thử với Java 7+:

 Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());

Có vẻ đầy hứa hẹn ...

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

Đọc và ghi tệp bằng cách sử dụng đầu vào và đầu ra:

//Coded By Anurag Goel
//Reading And Writing Files
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


public class WriteAFile {
    public static void main(String args[]) {
        try {
            byte array [] = {'1','a','2','b','5'};
            OutputStream os = new FileOutputStream("test.txt");
            for(int x=0; x < array.length ; x++) {
                os.write( array[x] ); // Writes the bytes
            }
            os.close();

            InputStream is = new FileInputStream("test.txt");
            int size = is.available();

            for(int i=0; i< size; i++) {
                System.out.print((char)is.read() + " ");
            }
            is.close();
        } catch(IOException e) {
            System.out.print("Exception");
        }
    }
}

Chỉ cần bao gồm gói này:

java.nio.file

Và sau đó bạn có thể sử dụng mã này để viết tệp:

Path file = ...;
byte[] buf = ...;
Files.write(file, buf);

Trong Java 8, sử dụng Tệp và Đường dẫn và sử dụng cấu trúc try-with-resource.

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class WriteFile{
    public static void main(String[] args) throws IOException {
        String file = "text.txt";
        System.out.println("Writing to file: " + file);
        // Files.newBufferedWriter() uses UTF-8 encoding by default
        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(file))) {
            writer.write("Java\n");
            writer.write("Python\n");
            writer.write("Clojure\n");
            writer.write("Scala\n");
            writer.write("JavaScript\n");
        } // the file will be automatically closed
    }
}

Có một số cách đơn giản, như:

File file = new File("filename.txt");
PrintWriter pw = new PrintWriter(file);

pw.write("The world I'm coming");
pw.close();

String write = "Hello World!";

FileWriter fw = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(fw);

fw.write(write);

fw.close();

Bạn thậm chí có thể tạo một tệp tạm thời bằng cách sử dụng thuộc tính hệ thống , nó sẽ độc lập với hệ điều hành bạn đang sử dụng.

File file = new File(System.*getProperty*("java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");

Sử dụng thư viện Guava của Google, chúng tôi có thể tạo và ghi vào tệp rất dễ dàng.

package com.zetcode.writetofileex;

import com.google.common.io.Files;
import java.io.File;
import java.io.IOException;

public class WriteToFileEx {

    public static void main(String[] args) throws IOException {

        String fileName = "fruits.txt";
        File file = new File(fileName);

        String content = "banana, orange, lemon, apple, plum";

        Files.write(content.getBytes(), file);
    }
}

Ví dụ tạo một fruits.txttệp mới trong thư mục gốc của dự án.

Đọc bộ sưu tập với khách hàng và lưu vào tập tin, với JFilechooser.

private void writeFile(){

    JFileChooser fileChooser = new JFileChooser(this.PATH);
    int retValue = fileChooser.showDialog(this, "Save File");

    if (retValue == JFileChooser.APPROVE_OPTION){

        try (Writer fileWrite = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileChooser.getSelectedFile())))){

            this.customers.forEach((c) ->{
                try{
                    fileWrite.append(c.toString()).append("\n");
                }
                catch (IOException ex){
                    ex.printStackTrace();
                }
            });
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}

Có ít nhất một số cách tạo tệp và ghi vào tệp:

Các tệp nhỏ (1.7)

Bạn có thể sử dụng một trong các phương thức ghi để ghi byte hoặc dòng vào tệp.

Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".;
Files.write(file, buf);

Các phương pháp này đảm nhiệm hầu hết các công việc cho bạn, chẳng hạn như mở và đóng luồng, nhưng không nhằm xử lý các tệp lớn.

Viết tệp lớn hơn bằng cách sử dụng I / O bộ đệm (1.7)

Các java.nio.filehỗ trợ gói kênh I / O, mà di chuyển dữ liệu trong bộ đệm, bỏ qua một số lớp có thể nút cổ chai dòng I / O.

String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
    writer.write(s, 0, s.length());
}

Cách tiếp cận này được ưu tiên do hiệu suất hiệu quả của nó đặc biệt là khi hoàn thành một lượng lớn thao tác ghi. Các hoạt động được đệm có tác dụng này vì chúng không bắt buộc phải gọi phương thức ghi của hệ điều hành cho mỗi byte đơn, giảm các hoạt động I / O tốn kém.

Sử dụng API NIO để sao chép (và tạo tệp mới) một tệp có Đầu ra (1.7)

Path oldFile = Paths.get("existing-file-path");
Path newFile = Paths.get("new-file-path");
try (OutputStream os = new FileOutputStream(newFile.toFile())) {
    Files.copy(oldFile, os);
}

Ngoài ra còn có các phương thức bổ sung cho phép sao chép tất cả các byte từ luồng đầu vào sang tệp.

FileWriter (văn bản) (<1.7)

Viết trực tiếp vào tập tin (hiệu suất thấp hơn) và chỉ nên được sử dụng khi số lần ghi ít hơn. Được sử dụng để ghi dữ liệu hướng nhân vật vào một tập tin.

String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();

FileOutputStream (nhị phân) (<1.7)

FileOutputStream có nghĩa là để ghi các luồng byte thô như dữ liệu hình ảnh.

byte data[] = "binary-to-write-to-file".getBytes();
FileOutputStream out = new FileOutputStream("file-name");
out.write(data);
out.close();

Với cách tiếp cận này, ta nên xem xét luôn luôn viết một mảng byte thay vì viết một byte mỗi lần. Việc tăng tốc có thể khá đáng kể - cao hơn tới 10 lần hoặc hơn. Do đó, nên sử dụng các write(byte[])phương pháp bất cứ khi nào có thể.