【发布时间】：2011-02-22 12:46:30
【问题描述】：
create and write to a (text) file in Java 的最简单方法是什么？
【问题讨论】：
-
请问为什么simple 很重要，因为您可以编写包含所需代码的函数/过程/方法；那么你只需要调用那个函数/过程/方法。只是为了省点打字吗？
【发布时间】：2011-02-22 12:46:30
【问题描述】：
请注意，下面的每个代码示例都可能抛出 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, 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);
【讨论】：
在 Java 7 及更高版本中：
try (Writer writer = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream("filename.txt"), "utf-8"))) {
writer.write("something");
}
虽然有一些有用的实用程序：
- FileUtils.writeStringtoFile(..) 来自 commons-io
- 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）。
【讨论】：
如果您已经有了要写入文件的内容（而不是动态生成的），Java 7 中作为本机 I/O 的一部分添加的 java.nio.file.Files 提供了最简单、最有效的方法来实现您的目标。
基本上创建和写入文件只有一行，而且一个简单的方法调用！
以下示例创建并写入 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();
}
【讨论】：
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();
}
}
}
}
【讨论】：
在 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.exists())file.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() 将自动关闭流。此版本简短、快速（缓冲）并支持选择编码。
此功能是在 Java 7 中引入的。
【讨论】：
这里我们将一个字符串输入到一个文本文件中：
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
我们可以轻松地创建一个新文件并向其中添加内容。
【讨论】：
-
请注意，关闭 BufferedWriter 就足够了，因为它还负责关闭 FileWriter。
由于作者没有具体说明他们是否需要针对已经 EoL 的 Java 版本的解决方案（Sun 和 IBM，它们在技术上是最普遍的 JVM），并且由于大多数人似乎在指定它是文本（非二进制）文件之前已经回答了作者的问题，我决定提供我的答案。
首先，Java 6 一般已经到了生命的尽头，由于作者没有说明他需要遗留兼容性，我猜它自动意味着 Java 7 或更高版本（Java 7 尚未被 IBM EoL'd）。所以，我们可以直接看文件I/O教程：https://docs.oracle.com/javase/tutorial/essential/io/legacy.html
在 Java SE 7 版本之前，java.io.File 类是 用于文件 I/O 的机制，但它有几个缺点。
- 许多方法在失败时并没有抛出异常，所以它是 无法获得有用的错误信息。例如，如果一个文件 删除失败，程序将收到“删除失败”但 不知道是不是因为文件不存在，用户不存在 有权限，或者有其他问题。
- 重命名方法 跨平台工作不一致。
- 没有真正的支持 用于符号链接。
- 需要对元数据提供更多支持，例如 文件权限、文件所有者和其他安全属性。访问 文件元数据效率低下。
- 许多 File 方法无法扩展。 通过服务器请求大型目录列表可能会导致 悬挂。大目录也可能导致内存资源问题， 导致拒绝服务。
- 无法写入 可以递归遍历文件树并响应的可靠代码 如果有循环符号链接，则适当。
哦，好吧，这排除了 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);
简化示例（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("----------");
[...]
}
这些方法对作者的工作量很小，在写入 [文本] 文件时应该优先于所有其他方法。
【讨论】：
如果您希望获得相对无痛的体验，您还可以查看Apache Commons IO package，更具体地说是FileUtils class。
永远不要忘记检查第三方库。 Joda-Time 用于日期操作，Apache Commons Lang StringUtils 用于常见字符串操作等可以使您的代码更具可读性。
Java 是一门很棒的语言，但标准库有时有点低级。功能强大，但仍然低级。
【讨论】：
以下是一些在 Java 中创建和编写文件的可能方法：
使用 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();
}
使用 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();
}
使用 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();
}
使用 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();
}
如需进一步查看有关如何read and write files in Java 的教程。
【讨论】：
如果你出于某种原因想要将创建和编写的行为分开，那么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() 进行存在性检查并自动创建文件。例如，如果您想在写入文件之前确保自己是文件的创建者，这将很有用。
【讨论】：
-
不，它没有用。只是打开文件进行输出，效果完全一样。
-
@user207421：我看到你在过去发布过这个和相关问题，但不清楚你在争论什么。简单地打开文件进行写入确实会确保在您写入文件时文件存在，但这就是为什么我说“如果你想将创建和写入的行为分开”和“如果您想确保您是文件的创建者。”从这个意义上说不，只是打开文件进行输出并没有相同的效果。
用途：
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);
}
【讨论】：
最好的方法是使用 Java7： Java 7 引入了一种使用文件系统的新方法，以及一个新的实用程序类——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();
}
使用 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 将 String 写入新文件：
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();
}
【讨论】：
我认为这是最短的方法：
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();
【讨论】：
创建文件而不覆盖现有文件：
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
}
【讨论】：
-
createNewFile()确实覆盖现有文件。
Java 7+ 值得一试：
Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());
看起来很有希望...
【讨论】：
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();
}
}
}
【讨论】：
-
flush()beforeclose()是多余的。
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");
}
}
【讨论】：
我能找到的最简单的方法：
Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
writer.write("Hello, world!");
}
它可能只适用于 1.7+。
【讨论】：
在 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
}
}
【讨论】：
这个答案以 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 │
└───────────────────────────┴──────────────────────────┴─────────────┴──────────────┘
【讨论】：
只有一行！
path 和 line 是字符串
import java.nio.file.Files;
import java.nio.file.Paths;
Files.write(Paths.get(path), lines.getBytes());
【讨论】：
使用输入输出流读写文件：
//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");
}
}
}
【讨论】：
只需包含这个包：
java.nio.file
然后你就可以用这段代码来写文件了：
Path file = ...;
byte[] buf = ...;
Files.write(file, buf);
【讨论】：
如果我们使用 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();
}
【讨论】：
使用 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 文件。
【讨论】：
有一些简单的方法，比如：
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();
【讨论】：
您甚至可以使用系统属性创建一个临时文件，该文件与您使用的操作系统无关。
File file = new File(System.*getProperty*("java.io.tmpdir") +
System.*getProperty*("file.separator") +
"YourFileName.txt");
【讨论】：
至少有几种创建文件和写入文件的方法：
小文件 (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（文本） (
直接写入文件（性能较低），仅应在写入次数较少时使用。用于将面向字符的数据写入文件。
String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();
FileOutputStream（二进制） (
FileOutputStream 用于写入原始字节流，例如图像数据。
byte data[] = "binary-to-write-to-file".getBytes();
FileOutputStream out = new FileOutputStream("file-name");
out.write(data);
out.close();
使用这种方法，应该考虑始终写入一个字节数组，而不是一次写入一个字节。加速可能非常显着 - 高达 10 倍或更多。因此建议尽可能使用write(byte[]) 方法。
【讨论】：