如何使用Java将字符串保存到文本文件？


How do I save a String to a text file using Java?

在爪哇中，我从文本字段中的文本字段中得到一个名为"text"的字符串变量。

如何将"text"变量的内容保存到文件中？

如果您只是输出文本，而不是任何二进制数据，那么以下操作将有效：

1
PrintWriter out = new PrintWriter("filename.txt");

然后，将字符串写入它，就像写入任何输出流一样：

1
out.println(text);

您将需要异常处理，一如既往。写完后一定要打电话给out.close()。

如果你正在使用Java 7或更高版本，你可以使用"尝试资源声明"，当你完成它时，它会自动关闭你的EDCOX1 2。

1
2
3
try (PrintWriter out = new PrintWriter("filename.txt")) {
    out.println(text);
}

您仍然需要像以前一样明确地抛出java.io.FileNotFoundException。

相关讨论

ApacheCommonsIO包含一些很好的方法，尤其是fileutils包含以下方法：

1
static void writeStringToFile(File file, String data)

它允许您在一个方法调用中将文本写入文件：

1
FileUtils.writeStringToFile(new File("test.txt"),"Hello File");

您可能还需要考虑为文件指定编码。

相关讨论

看一下Java文件API

一个简单的例子：

1
2
3
try (PrintStream out = new PrintStream(new FileOutputStream("filename.txt"))) {
    out.print(text);
}
相关讨论

只是在我的项目中做了类似的事情。使用FileWriter可以简化部分工作。在这里你可以找到很好的教程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
BufferedWriter writer = null;
try
{
    writer = new BufferedWriter( new FileWriter( yourfilename));
    writer.write( yourstring);

}
catch ( IOException e)
{
}
finally
{
    try
    {
        if ( writer != null)
        writer.close( );
    }
    catch ( IOException e)
    {
    }
}
相关讨论

在Java 7中，您可以这样做：

1
2
3
String content ="Hello File!";
String path ="C:/a.txt";
Files.write( Paths.get(path), content.getBytes(), StandardOpenOption.CREATE);

这里有更多信息：http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

相关讨论

使用Apache Commons IO中的FileUtils.writeStringToFile()。不需要重新发明这个轮子。

相关讨论

您可以使用下面的修改代码从处理文本的任何类或函数中写入文件。但有人想知道为什么世界需要一个新的文本编辑器…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.io.*;

public class Main {

    public static void main(String[] args) {

        try {
            String str ="SomeMoreTextIsHere";
            File newTextFile = new File("C:/thetextfile.txt");

            FileWriter fw = new FileWriter(newTextFile);
            fw.write(str);
            fw.close();

        } catch (IOException iox) {
            //do stuff with exception
            iox.printStackTrace();
        }
    }
}
相关讨论

使用Apache Commons IO API。其简单

使用API作为

1
 FileUtils.writeStringToFile(new File("FileNameToWrite.txt"),"stringToWrite");

Maven依赖

1
2
3
4
5
<dependency>
    <groupId>commons-io</groupId>
    commons-io</artifactId>
    <version>2.4</version>
</dependency>

我更喜欢尽可能依赖图书馆来进行这种操作。这使得我不太可能不小心遗漏了一个重要步骤(就像上面沃尔夫斯奈普斯犯的错误)。上面提到了一些图书馆，但我最喜欢的是谷歌的番石榴。guava有一个名为files的类，可以很好地用于此任务：

1
2
3
4
5
6
7
8
9
10
// This is where the file goes.
File destination = new File("file.txt");
// This line isn't needed, but is really useful
// if you're a beginner and don't know where your file is going to end up.
System.out.println(destination.getAbsolutePath());
try {
    Files.write(text, destination, Charset.forName("UTF-8"));
} catch (IOException e) {
    // Useful error handling here
}
相关讨论

如果需要基于单个字符串创建文本文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class StringWriteSample {
    public static void main(String[] args) {
        String text ="This is text to be saved in file";

        try {
            Files.write(Paths.get("my-file.txt"), text.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.io.*;

private void stringToFile( String text, String fileName )
 {
 try
 {
    File file = new File( fileName );

    // if file doesnt exists, then create it
    if ( ! file.exists( ) )
    {
        file.createNewFile( );
    }

    FileWriter fw = new FileWriter( file.getAbsoluteFile( ) );
    BufferedWriter bw = new BufferedWriter( fw );
    bw.write( text );
    bw.close( );
    //System.out.println("Done writing to" + fileName); //For testing
 }
 catch( IOException e )
 {
 System.out.println("Error:" + e);
 e.printStackTrace( );
 }
} //End method stringToFile

可以将此方法插入类中。如果在具有主方法的类中使用此方法，请通过添加静态关键字将此类更改为静态。无论哪种方式，您都需要导入java. IO。*使其工作，否则文件、文件写入器和BufferedWriter将不被识别。

在Java 11中，通过两个新的实用方法来扩展EDCOX1×0的类，将一个字符串写入文件中(参见JavaDoc此处和此处)。在最简单的情况下，它现在是一个一行程序：

1
Files.writeString(Paths.get("some/path"),"some_string");

使用可选的varargs参数，可以设置其他选项，例如附加到现有文件或自动创建不存在的文件(请参见此处的javadoc)。

使用这个，它是非常可读的：

1
2
3
4
import java.nio.file.Files;
import java.nio.file.Paths;

Files.write(Paths.get(path), lines.getBytes(), StandardOpenOption.WRITE);
相关讨论

使用Java 7：

1
2
3
4
5
6
public static void writeToFile(String text, String targetFilePath) throws IOException
{
    Path targetPath = Paths.get(targetFilePath);
    byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
    Files.write(targetPath, bytes, StandardOpenOption.CREATE);
}
相关讨论

你可以这样做：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.io.*;
import java.util.*;

class WriteText
{
    public static void main(String[] args)
    {  
        try {
            String text ="Your sample content to save in a text file.";
            BufferedWriter out = new BufferedWriter(new FileWriter("sample.txt"));
            out.write(text);
            out.close();
        }
        catch (IOException e)
        {
            System.out.println("Exception");      
        }

        return ;
    }
};

使用org.apache.commons.io.fileutils：

1
FileUtils.writeStringToFile(new File("log.txt"),"my string", Charset.defaultCharset());

如果您只关心将一个文本块推送到文件中，那么每次都会覆盖它。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showSaveDialog(this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
    FileOutputStream stream = null;
    PrintStream out = null;
    try {
        File file = chooser.getSelectedFile();
        stream = new FileOutputStream(file);
        String text ="Your String goes here";
        out = new PrintStream(stream);
        out.print(text);                  //This will overwrite existing contents

    } catch (Exception ex) {
        //do something
    } finally {
        try {
            if(stream!=null) stream.close();
            if(out!=null) out.close();
        } catch (Exception ex) {
            //do something
        }
    }
}

此示例允许用户使用文件选择器选择文件。

相关讨论

最好在finally块中关闭writer/outputstream，以防万一

1
2
3
4
5
6
7
8
9
10
11
finally{
   if(writer != null){
     try{
        writer.flush();
        writer.close();
     }
     catch(IOException ioe){
         ioe.printStackTrace();
     }
   }
}
相关讨论

您可以使用arraylist将文本区域的所有内容作为示例，并通过调用save作为参数发送，因为编写器刚刚编写了字符串行，然后我们使用"for"一行一行地编写arraylist，最后我们将在txt文件中成为内容文本区域。如果有什么不合理的，我很抱歉是谷歌翻译和我谁不说英语。

观看Windows记事本，它并不总是跳转行，并显示在一行中，使用写字板确定。

private void saveactionperformed(java.awt.event.actionevent evt){

1
2
3
4
5
6
String NameFile = Name.getText();
ArrayList< String > Text = new ArrayList< String >();

Text.add(TextArea.getText());

SaveFile(NameFile, Text);

}

public void savefile(string name，arraylistmessage){

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
path ="C:\\Users\\Paulo Brito\\Desktop\" + name +".txt";

File file1 = new File(path);

try {

    if (!file1.exists()) {

        file1.createNewFile();
    }


    File[] files = file1.listFiles();


    FileWriter fw = new FileWriter(file1, true);

    BufferedWriter bw = new BufferedWriter(fw);

    for (int i = 0; i < message.size(); i++) {

        bw.write(message.get(i));
        bw.newLine();
    }

    bw.close();
    fw.close();

    FileReader fr = new FileReader(file1);

    BufferedReader br = new BufferedReader(fr);

    fw = new FileWriter(file1, true);

    bw = new BufferedWriter(fw);

    while (br.ready()) {

        String line = br.readLine();

        System.out.println(line);

        bw.write(line);
        bw.newLine();

    }
    br.close();
    fr.close();

} catch (IOException ex) {
    ex.printStackTrace();
    JOptionPane.showMessageDialog(null,"Error in" + ex);

}

我认为最好的方法是使用Files.write(Path path, Iterable lines, OpenOption... options)：

1
2
3
String text ="content";
Path path = Paths.get("path","to","file");
Files.write(path, Arrays.asList(text));

见JavaDoc：

Write lines of text to a file. Each line is a char sequence and is
written to the file in sequence with each line terminated by the
platform's line separator, as defined by the system property
line.separator. Characters are encoded into bytes using the specified
charset.

The options parameter specifies how the the file is created or opened.
If no options are present then this method works as if the CREATE,
TRUNCATE_EXISTING, and WRITE options are present. In other words, it
opens the file for writing, creating the file if it doesn't exist, or
initially truncating an existing regular-file to a size of 0. The
method ensures that the file is closed when all lines have been
written (or an I/O error or other runtime exception is thrown). If an
I/O error occurs then it may do so after the file has created or
truncated, or after some bytes have been written to the file.

请注意。我看到人们已经用Java的内置EDCOX1 6来回答，但是在我的答案中有什么特别之处，似乎没有人提到的是重载版本的方法，它采用了一个字符序列的迭代(即字符串)，而不是一个EDCOX1×7的数组，因此，不需要EDCOX1×8，这是一个更干净的想法。

如果希望将回车符从字符串保存到文件中下面是一个代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
    jLabel1 = new JLabel("Enter SQL Statements or SQL Commands:");
    orderButton = new JButton("Execute");
    textArea = new JTextArea();
    ...


    // String captured from JTextArea()
    orderButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent ae) {
            // When Execute button is pressed
            String tempQuery = textArea.getText();
            tempQuery = tempQuery.replaceAll("
","

");
            try (PrintStream out = new PrintStream(new FileOutputStream("C:/Temp/tempQuery.sql"))) {
                out.print(tempQuery);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(tempQuery);
        }

    });

我的方法是基于流，因为运行在所有的Android版本上，并且需要像url/uri这样的有用资源，任何建议都是受欢迎的。

就目前而言，流(inputstream和outputstream)传输二进制数据时，当开发人员将字符串写入流时，必须首先将其转换为字节，或者换句话说对其进行编码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public boolean writeStringToFile(File file, String string, Charset charset) {
    if (file == null) return false;
    if (string == null) return false;
    return writeBytesToFile(file, string.getBytes((charset == null) ? DEFAULT_CHARSET:charset));
}

public boolean writeBytesToFile(File file, byte[] data) {
    if (file == null) return false;
    if (data == null) return false;
    FileOutputStream fos;
    BufferedOutputStream bos;
    try {
        fos = new FileOutputStream(file);
        bos = new BufferedOutputStream(fos);
        bos.write(data, 0, data.length);
        bos.flush();
        bos.close();
        fos.close();
    } catch (IOException e) {
        e.printStackTrace();
        Logger.e("!!! IOException");
        return false;
    }
    return true;
}