Question

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

Answer 1

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

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

创建文本文件：

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

Java 7 + 用户可以使用Files类写入文件：

创建文本文件：

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

创建二进制文件：

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

Answer 2

在Java 7及更高版本中：

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

虽然有以下方面的实用工具：

FileUtils.writeStringtoFile(..)
Files.write(..)

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

以下是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*/}
}

另见：Reading, Writing, and Creating Files（包括NIO2）。

Answer 3

如果您已经拥有要写入文件的内容（而不是动态生成），则Java 7中的java.nio.file.Files添加作为本机I / O的一部分提供了最简单，最有效的方法实现你的目标。

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

以下示例创建并写入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();
}

Answer 4

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

Answer 5

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

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

Answer 6

使用：

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()会自动关闭流。此版本简短，快速（缓冲）并允许选择编码。

此功能是在Java 7中引入的。

Answer 7

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

参考：File create Example in java

Answer 8

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

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

我们可以轻松创建新文件并在其中添加内容。

Answer 9

如果您希望获得相对无痛苦的体验，您还可以查看Apache Commons IO package，更具体地说是FileUtils class。

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

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

Answer 10

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

首先，Java 6通常已经达到使用寿命，并且由于作者没有指定他需要遗留兼容性，我想它自动意味着Java 7或更高版本（Java 7尚未由IBM进行EoL）。因此，我们可以正确查看文件I / O教程：https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

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


许多方法在失败时都没有抛出异常，所以就是这样   无法获得有用的错误消息。例如，如果是文件   删除失败，程序将收到“删除失败”，但   不知道是不是因为文件不存在，用户没有   有权限，或者还有其他一些问题。

重命名方法   不能跨平台一致地工作。

没有真正的支持   用于符号链接。

需要更多支持元数据，例如   文件权限，文件所有者和其他安全属性。访问   文件元数据效率低下。

许多File方法都没有扩展。   通过服务器请求大型目录列表可能会导致a   挂。大目录也可能导致内存资源问题，   导致拒绝服务。

无法写作   可靠的代码，可以递归地遍历文件树并做出响应   适当的，如果有圆形符号链接。

哦，那排除了java.io.File。如果无法写入/追加文件，您可能无法知道原因。

我们可以继续查看教程：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...-

简化示例（Java 8或更高版本）：

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]文件时应该优先于所有其他方法。

Answer 11

如果由于某种原因想要分离创建和编写的行为，那么touch的Java等价物

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()执行存在检查并以原子方式创建文件。例如，如果您想在写入文件之前确保自己是文件的创建者，这将非常有用。

Answer 12

使用：

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

Answer 13

我认为这是最短的方式：

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

Answer 14

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

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
}

Answer 15

以下是使用Java创建和编写文件的一些可能方法：

使用FileOutputStream

import React, {Component} from 'react';
import {connect} from 'react-redux';
import { BrowserRouter,Switch, Route, Redirect } from 'react-router-dom';
import PrivateMainLayout from '../layouts/PrivateMainLayout';
import AuthenticatedRoute from '../AuthenticatedRoute';
import Login from '../pages/Login';

export class LoginLayout extends Component{
    constructor(){
        super();
        this.state = {

        };
    }

    render(){
        return(
            <BrowserRouter>
                <div>
                    <Switch>
                        <Route path="/bis/login" exact component={Login}/>
                        <AuthenticatedRoute login={this.props.login} path="/bis" component={PrivateMainLayout}/>
                    </Switch>
                </div>
            </BrowserRouter>
        )
    }
}

function mapStateToProps(state){
    return{
        login: state.login
    };
}
export default connect(mapStateToProps, null)(LoginLayout);

使用FileWriter

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

使用PrintWriter

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

使用OutputStreamWriter

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

有关如何进一步查看本教程如何read and write files in Java。

Answer 16

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

Answer 17

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

Answer 18

我能找到最简单的方法：

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

它可能仅适用于1.7 +。

Answer 19

仅限一行！ path和line是字符串

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

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

Answer 20

最好的方法是使用Java7： Java 7引入了使用文件系统的新方法，以及新的实用程序类–文件。使用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();
}

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

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

Answer 21

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

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

Answer 22

如果我们使用Java 7及更高版本并且还知道要添加（附加）到文件的内容，我们可以在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();
    }
}

有几点需要注意：

指定字符集编码总是一个好习惯，为此我们在课程StandardCharsets中保持不变。
代码使用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();
}

Answer 23

值得一试Java 7 +：

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

看起来很有希望......

Answer 24

在Java 8中，使用文件和路径并使用try-with-resources构造。

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

Answer 25

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

小文件（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());
}

该方法由于其高效的性能而被优先考虑，尤其是在完成大量写操作时。缓冲操作具有这种效果，因为不需要为每个字节调用操作系统的write方法，从而减少了昂贵的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();

FileOutputStream（二进制）（<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[])方法。

Answer 26

您甚至可以使用系统属性创建临时文件，该文件与您正在使用的操作系统无关。

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

Answer 27

有一些简单的方法，例如：

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

Answer 28

此答案集中在Java 8上，它试图涵盖Java Professional Exam所需的所有细节。它试图解释为什么存在不同的方法。它们每个都有其优点，并且在给定情况下可能最简单。

涉及的课程包括：

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

FileOutputStream

此类用于编写原始字节流。下面的所有Writer方法都显式地或under the hood都依赖于此类。

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

请注意，try-with-resources statement会处理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) {}

在Java 5之前，这是处理大型文件（带有常规try / catch块）的最佳方法。

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()方法的控制，它们在nearly the same way中起作用。

请注意：

没有缓冲，但是要处理大文件，可以将其包装在BufferedWriter中。
FileWriter使用默认编码。通常最好明确指定编码

PrintWriter

此类将对象的格式化表示形式打印到文本输出流。实际情况与上面的BufferedWriter方法（new BufferedWriter(new OutputStreamWriter(new FileOutputStream(...)))）相同。 PrintWriter是Java 5中引入的一种方便的调用方式，它添加了其他方法，例如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（）

Java 7引入了java.nio.file.Files。 Files.write()使您可以在单个调用中创建和写入文件。

@icza's answer显示了如何使用此方法。几个例子：

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

Java 7还引入了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的方法，doesn't swallow exceptions的好处。

摘要

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

Answer 29

使用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文件。

Answer 30

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

Answer 31

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

Answer 32

创建示例文件：

this

如何创建文件并用Java写入？

32 个答案: