如何创建文件并写入它？

在Java中创建并写入（文本）文件最简单的方法是什么？

3095353 次浏览
小开
最佳答案

请注意，下面的每个代码示例都可能抛出IOException。为了简洁起见，已省略了try/catch/最终块。有关异常处理的信息，请参阅本教程。

请注意，如果文件已经存在，下面的每个代码示例都将覆盖该文件

创建文本文件：

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

创建一个二进制文件：

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

Java7+用户可以使用#0类写入文件：

创建文本文件：

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

创建一个二进制文件：

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

Java7及以上：

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

不过，有一些有用的实用程序：

另请注意，可以使用FileWriter，但它使用默认编码，这通常是个坏主意-最好显式指定编码。

以下是原始的，Java7之前的答案

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

另见：读取、写入和创建文件（包括NIO2）。

小开 
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 ) {try {output.close();}catch (IOException e){e.printStackTrace();}}}}}
小开

如果你想有一个相对无痛的体验，你也可以看看Apache Commons IO包，更具体地说#0类。

永远不要忘记检查第三方库。Joda-Time用于日期操作，Apache Commons Lang#0用于常见的字符串操作，这样可以使您的代码更具可读性。

Java是一种很棒的语言，但标准库有时有点低级。功能强大，但仍然是低级的。

小开

如果您出于某种原因想要将创建和编写行为分开，Java等效于touch

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

createNewFile()以原子方式进行存在检查和文件创建。例如，如果您想确保您在写入文件之前是文件的创建者，这可能很有用。

小开

这是一个创建或覆盖文件的小示例程序。它的版本很长，因此可以更容易地理解。

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

用途：

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

使用try()将自动关闭流。此版本简短、快速（缓冲）并允许选择编码。

这个特性是在Java7中引入的。

小开

如果您已经有了要写入文件的内容（并且不是动态生成的），那么作为本机I/O的一部分，Java7中的#0添加提供了实现目标的最简单、最有效的方法。

基本上创建和写入文件只有一行，而且一个简单的方法调用！

以下示例创建并写入6个不同的文件以展示如何使用它：

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

在这里，我们将字符串输入到文本文件中：

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

我们可以轻松创建一个新文件并将内容添加到其中。

小开

要创建文件而不覆盖现有文件：

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 variableString newfile = f + "\\hi.doc";//.txt or .doc or .htmlFile 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}
小开

用途：

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

我能找到的最简单的方法：

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

它可能只适用于1.7+。

小开

使用输入和输出流进行文件读写：

//Coded By Anurag Goel//Reading And Writing Filesimport 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");}}}
小开

只有一条线！path和line是字符串

import java.nio.file.Files;import java.nio.file.Paths;
Files.write(Paths.get(path), lines.getBytes());
小开

我认为这是最短的路：

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

只需包含此包：

java.nio.file

然后您可以使用此代码编写文件：

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

由于作者没有说明他们是否需要一个已经EoL过的Java版本的解决方案（Sun和IBM都有，这些在技术上是最广泛的JVM），并且由于大多数人似乎在指定它是文本（非二进制）文件之前已经回答了作者的问题，我决定提供我的答案。

首先，Java6通常已经到了生命的尽头，由于作者没有指定他需要遗留兼容性，我想它自动意味着Java7或更高（Java7还没有IBM）。

在JavaSE 7发布之前，java.io.File类是用于文件I/O的机制，但它有几个缺点。

  • 许多方法在失败时没有抛出异常，因此无法获得有用的错误消息。例如，如果文件删除失败，程序将收到“删除失败”，但不知道是不是因为文件不存在，用户不存在有权限，或者有其他问题。
  • 重命名方法不能在不同平台上一致工作。
  • 没有真正的支持用于符号链接。
  • 需要更多对元数据的支持，例如文件权限、文件所有者和其他安全属性。访问文件元数据效率低下。
  • 许多File方法没有缩放。在服务器上请求大目录列表可能会导致挂起。大型目录也可能导致内存资源问题，导致拒绝服务。
  • 写是不可能的可靠的代码，可以递归遍历文件树并响应如果有循环符号链接，则适当。

哦，那就排除了java.io.文件。如果一个文件不能写入/附加，你甚至可能不知道为什么。

我们可以继续看教程：https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

如果您有所有行，您将提前写入（追加）到文本文件，推荐的方法是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...-

举个例子（简化）：

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

另一个例子（追加）：

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

如果您想随时写入文件内容：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...-

简化示例（Java8或以上）：

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

另一个例子（追加）：

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

这些方法对作者来说需要最小的努力，并且在写入[text]文件时应该优先于所有其他方法。

小开 
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 filewriter.write("Enter the text that you want to write");writer.flush();writer.close();System.out.println("Data is entered into file");}}
小开

如果我们使用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.txttry (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();}
小开

有一些简单的方法，如：

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

在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 fileString 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 itif (!file.exists()) {file.createNewFile();}
FileWriter fw = new FileWriter(file.getAbsoluteFile());BufferedWriter bw = new BufferedWriter(fw);
// Write in filebw.write(content);
// Close connectionbw.close();}catch(Exception e){System.out.println(e);}}}
小开

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

值得一试的Java7+：

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

看起来很有希望…

小开

您甚至可以使用系统属性创建一个临时文件，这将与您使用的操作系统无关。

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

使用Google的Guava库，我们可以非常轻松地创建和写入文件很容易

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

该示例在项目根目录中创建一个新的fruits.txt文件。

小开

创建示例文件：

try {File file = new File ("c:/new-file.txt");if(file.createNewFile()) {System.out.println("Successful created!");}else {System.out.println("Failed to create!");}}catch (IOException e) {e.printStackTrace();}
小开

以下是在Java中创建和写入文件的一些可能方法：

使用文件输出流

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 founde.printStackTrace();} catch (IOException e) {// Problem when writing to the filee.printStackTrace();}

使用FileWriter

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

使用PrintWriter

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

使用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 founde.printStackTrace();} catch (IOException e) {// Error when writing to the filee.printStackTrace();}

有关详细信息，请查看有关如何在Java中读写文件的教程。

小开

在Java8中，使用文件和路径并使用try-with-资源构造。

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

最好的方法是使用Java7：Java7引入了一种使用文件系统的新方法，以及一个新的实用程序类-Files。使用Files类，我们也可以创建、移动、复制、删除文件和目录；它也可以用来读写文件。

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

使用FileChannel写入如果您正在处理大文件，FileChannel可以比标准IO更快。以下代码使用FileChannel将String写入文件：

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

写数据输出流

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

使用FileOutputStream写入

现在让我们看看如何使用FileOutputStream将二进制数据写入文件。以下代码转换String int字节并使用FileOutputStream将字节写入文件：

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

使用PrintWriter编写我们可以使用PrintWriter将格式化文本写入文件：

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

使用BufferedWriter写作：使用BufferedWriter将字符串写入新文件：

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

将字符串附加到现有文件：

public void saveDataInFile(String data) throws IOException {BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));writer.append(' ');writer.append(data);
writer.close();}
小开 
    public static void writefromFile(ArrayList<String> lines, String destPath) {FileWriter fw;try {fw = new FileWriter(destPath);for (String str : lines) {fw.write(str);}fw.close();} catch (IOException ex) {JOptionPane.showMessageDialog("ERROR: exception was: " + ex.toString());}File f = new File(destPath);f.setExecutable(true);}
小开

至少有几种方法可以创建文件并写入文件：

小文件（1.7）

您可以使用其中一种写入方法将字节或行写入文件。

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

这些方法为您处理大部分工作，例如打开和关闭流，但不适用于处理大文件。

使用缓冲流I/O编写更大的文件（1.7）

java.nio.file包支持通道I/O，它在缓冲区中移动数据，绕过一些可能瓶颈流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());}

这种方法因其高效的性能而优先，尤其是在完成大量写操作时。缓冲操作具有这种效果，因为它们不需要为每个字节调用操作系统的写方法，从而减少了昂贵的I/O操作。

使用NIO API复制（并创建一个新的）带有Outputstream的文件（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);}

还有其他方法允许将输入流中的所有字节复制到文件中。

FileWriter（文本）（<1.7）

直接写入文件（性能较差），仅应在写入次数较少时使用。用于将面向字符的数据写入文件。

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

文件输出流（<1.7）

FileOutputStream用于写入原始字节流，例如图像数据。

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

使用这种方法，应该考虑始终写入一个字节数组，而不是一次写入一个字节。加速比可能相当显着-高达10倍或更多。因此，建议尽可能使用write(byte[])方法。

小开

写入文件的方式有很多种，每种方式都有其优点，并且在给定场景中每种方式都可能是最简单的。

这个答案集中在Java8，并试图涵盖Java专业考试所需的所有细节。

.├── OutputStream│   └── FileOutputStream├── Writer│   ├── OutputStreamWriter│   │   └── FileWriter│   ├── BufferedWriter│   └── PrintWriter (Java 5+)└── Files (Java 7+)

有5种写入文件的主要方式：

┌───────────────────────────┬────────────────────────┬─────────────┬──────────────┐│                           │       Buffer for       │ Can specify │   Throws     ││                           │      large files?      │  encoding?  │ IOException? │├───────────────────────────┼────────────────────────┼─────────────┼──────────────┤│ OutputStreamWriter        │ Wrap in BufferedWriter │ Y           │ Y            ││ FileWriter                │ Wrap in BufferedWriter │             │ Y            ││ PrintWriter               │ Y                      │ Y           │              ││ Files.write()             │                        │ Y           │ Y            ││ Files.newBufferedWriter() │ Y                      │ Y           │ Y            │└───────────────────────────┴────────────────────────┴─────────────┴──────────────┘

每个人都有自己独特的好处：

  • OutputStreamWriter-Java5之前的最基本方式
  • FileWriter-可选的append构造函数参数
  • PrintWriter-很多方法
  • Files.write()-在单个调用中创建并写入文件
  • Files.newBufferedWriter()-轻松编写大文件

下面是每个细节。

文件输出流

此类用于写入原始字节流。下面的所有Writer方法都依赖于此类，无论是显式还是在引擎盖下。

try (FileOutputStream stream = new FileOutputStream("file.txt");) {byte data[] = "foo".getBytes();stream.write(data);} catch (IOException e) {}

请注意，使用资源尝试语句处理stream.close()，关闭流会刷新它，就像stream.flush()一样。下面的所有示例都使用这种方法。

OutputStreamWriter

此类是从字符流到字节流的桥梁。它可以包装FileOutputStream，并编写字符串：

Charset utf8 = StandardCharsets.UTF_8;try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(new File("file.txt")), utf8)) {writer.write("foo");} catch (IOException e) {}

BufferedWriter

此类将文本写入字符输出流，缓冲字符以提供单个字符、数组和字符串的有效写入。

它可以包装一个OutputStreamWriter：

try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("file.txt"))))) {writer.write("foo");writer.newLine();  // method provided by BufferedWriter} catch (IOException e) {}

在Java5之前，这是大文件的最佳方法（使用常规的try/cat块）。

FileWriter

这是OutputStreamWriter的子类，是编写字符文件的方便类：

boolean append = false;try(FileWriter writer = new FileWriter("file.txt", append) ){writer.write("foo");writer.append("bar");} catch (IOException e) {}

关键的好处是它有一个可选的append构造函数参数，它确定它是附加到还是覆盖现有文件。请注意，追加/覆盖行为不受write()和append()方法的控制，它们的行为在几乎相同的方式中。

注意：

  • 没有缓冲，但要处理大文件，它可以包装在BufferedWriter中。
  • FileWriter使用默认编码。通常最好显式指定编码

PrintWriter

这个类将对象的格式化表示打印到文本输出流中。在幕后，它与上面（new BufferedWriter(new OutputStreamWriter(new FileOutputStream(...)))）的BufferedWriter方法相同。PrintWriter是在Java5中引入的，作为调用这个习惯用法的方便方法，并添加了其他方法，例如printf()和println()。

此类中的方法不会抛出I/O异常。您可以通过调用checkError()来检查错误。PrintWriter实例的目标可以是File、OutputStream或Writer。这是写入文件的示例：

try (PrintWriter writer = new PrintWriter("file.txt", "UTF-8")) {writer.print("foo");writer.printf("bar %d $", "a", 1);writer.println("baz");} catch (FileNotFoundException e) {} catch (UnsupportedEncodingException e) {}

写入OutputStream或Writer时，有一个可选的autoFlush构造函数参数，默认为false。与FileWriter不同，它将覆盖任何现有文件。

Files.write（）

Java7引入了#0。Files.write()允许您在一次调用中创建和写入文件。

@陈志立展示了如何使用这个方法。几个例子：

Charset utf8 = StandardCharsets.UTF_8;List<String> lines = Arrays.asList("foo", "bar");
try {Files.write(Paths.get("file.txt"), "foo".getBytes(utf8));Files.write(Paths.get("file2.txt"), lines, utf8);} catch (IOException e) {}

这不涉及缓冲区，因此不适合大文件。

Files.newBufferedWriter（）

Java7还引入了Files.newBufferedWriter()，这使得获得BufferedWriter变得容易：

Charset utf8 = StandardCharsets.UTF_8;try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("file.txt"), utf8)) {writer.write("foo");} catch (IOException e) {}

这类似于PrintWriter，缺点是没有PrintWriter的方法，好处是它不会吞下例外。

小开

在Java11+中，编写纯文本：

Files.writeString(Path.of("filename.txt"), "some-text");
小开

以下是编写文件的代码，并在退出帮助内容网页时删除：

public String writeHelpContent(String filePath, String helpPageContent) throws IOException{logger.info("HowToUseRiskOfficeHelpService - writeHelpContent start");File file = new File(filePath);try(FileWriter fw = new FileWriter(file);){file.deleteOnExit();if(file.createNewFile()) {logger.info("HowToUseRiskOfficeHelpService - file created successfully");}else {logger.info("HowToUseRiskOfficeHelpService - file already exists");}fw.write(helpPageContent);fw.flush();}
return "Sucessfully write into help page file";}

提交答案