Làm cách nào để lưu Chuỗi vào tệp văn bản bằng Java?

Trong Java, tôi có văn bản từ một trường văn bản trong một biến Chuỗi gọi là "văn bản".

Làm cách nào để lưu nội dung của biến "văn bản" vào một tệp?

Nếu bạn chỉ đơn giản xuất ra văn bản, thay vì bất kỳ dữ liệu nhị phân nào, những điều sau đây sẽ hoạt động:

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

Sau đó, viết Chuỗi của bạn vào nó, giống như bạn làm với bất kỳ luồng đầu ra nào:

out.println(text);

Bạn sẽ cần xử lý ngoại lệ, như mọi khi. Hãy chắc chắn gọiout.close() khi bạn đã viết xong.

Nếu bạn đang sử dụng Java 7 trở lên, bạn có thể sử dụng " câu lệnh thử tài nguyên " sẽ tự động đóng PrintStreamkhi bạn hoàn thành với nó (tức là thoát khỏi khối) như vậy:

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

Bạn vẫn sẽ cần phải ném một cách rõ ràng java.io.FileNotFoundExceptionnhư trước đây.

Apache Commons IO chứa một số phương thức tuyệt vời để làm điều này, cụ thể là FileUtils chứa phương thức sau:

static void writeStringToFile(File file, String data) 

cho phép bạn viết văn bản vào một tệp trong một cuộc gọi phương thức:

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

Bạn cũng có thể muốn xem xét chỉ định mã hóa cho tệp.

Hãy xem API tệp Java

một ví dụ nhanh:

try (PrintStream out = new PrintStream(new FileOutputStream("filename.txt"))) {
    out.print(text);
}

Trong Java 7, bạn có thể làm điều này:

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

Có thêm thông tin ở đây: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

Chỉ cần làm một cái gì đó tương tự trong dự án của tôi. Sử dụng FileWriter sẽ đơn giản hóa một phần công việc của bạn. Và ở đây bạn có thể tìm thấy hướng dẫn tốt đẹp .

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

Sử dụng FileUtils.writeStringToFile()từ Apache Commons IO . Không cần phải phát minh lại bánh xe đặc biệt này.

Bạn có thể sử dụng sửa đổi mã dưới đây để ghi tệp của bạn từ bất kỳ lớp hoặc chức năng nào đang xử lý văn bản. Người ta tự hỏi tại sao thế giới cần một trình soạn thảo văn bản mới ...

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

Trong Java 11 , java.nio.file.Fileslớp được mở rộng bằng hai phương thức tiện ích mới để viết một chuỗi vào một tệp. Phương thức đầu tiên (xem JavaDoc tại đây ) sử dụng bộ ký tự UTF-8 làm mặc định:

Files.writeString(Path.of("my", "path"), "My String");

Và phương thức thứ hai (xem JavaDoc tại đây ) cho phép chỉ định một bộ ký tự riêng lẻ:

Files.writeString(Path.of("my", "path"), "My String", StandardCharset.ISO_8859_1);

Cả hai phương thức đều có tham số Varargs tùy chọn để thiết lập các tùy chọn xử lý tệp (xem JavaDoc tại đây ). Ví dụ sau sẽ tạo một tệp không tồn tại hoặc nối chuỗi vào một tệp hiện có:

Files.writeString(Path.of("my", "path"), "String to append", StandardOpenOption.CREATE, StandardOpenOption.APPEND);

Tôi thích dựa vào các thư viện bất cứ khi nào có thể cho loại hoạt động này. Điều này làm cho tôi ít có khả năng vô tình bỏ qua một bước quan trọng (như lỗi sói đã làm ở trên). Một số thư viện được đề xuất ở trên, nhưng yêu thích của tôi cho loại điều này là Google Guava . Quả ổi có một lớp gọi là Tệp hoạt động độc đáo cho nhiệm vụ này:

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

Sử dụng Apache Commons IO api. Nó đơn giản

Sử dụng API như

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

Phụ thuộc Maven

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>

Trong trường hợp nếu bạn cần tạo tệp văn bản dựa trên một chuỗi đơn:

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

Sử dụng cái này, nó rất dễ đọc:

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

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

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

Bạn có thể chèn phương thức này vào các lớp học của bạn. Nếu bạn đang sử dụng phương thức này trong một lớp với một phương thức chính, hãy thay đổi lớp này thành tĩnh bằng cách thêm từ khóa tĩnh. Dù bằng cách nào bạn cũng sẽ cần nhập java.io. * để làm cho nó hoạt động nếu không File, FileWriter và BufferedWriter sẽ không được nhận ra.

Bạn có thể làm điều này:

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

Sử dụng Java 7:

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

Sử dụng org.apache.commons.io.FileUtils:

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

Nếu bạn chỉ quan tâm đến việc đẩy một khối văn bản vào tệp, điều này sẽ ghi đè lên mỗi lần.

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

Ví dụ này cho phép người dùng chọn một tệp bằng cách sử dụng trình chọn tệp.

Tốt hơn là đóng trình ghi / đầu ra trong một khối cuối cùng, trong trường hợp có điều gì đó xảy ra

finally{
   if(writer != null){
     try{
        writer.flush();
        writer.close();
     }
     catch(IOException ioe){
         ioe.printStackTrace();
     }
   }
}

private static void generateFile(String stringToWrite, String outputFile) {
try {       
    FileWriter writer = new FileWriter(outputFile);
    writer.append(stringToWrite);
    writer.flush();
    writer.close();
    log.debug("New File is generated ==>"+outputFile);
} catch (Exception exp) {
    log.error("Exception in generateFile ", exp);
}

}

Tôi nghĩ rằng cách tốt nhất là sử dụng Files.write(Path path, Iterable<? extends CharSequence> lines, OpenOption... options):

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

Xem javadoc :

Viết các dòng văn bản vào một tập tin. Mỗi dòng là một chuỗi char và được ghi vào tệp theo trình tự với mỗi dòng được kết thúc bằng dấu tách dòng của nền tảng, như được định nghĩa bởi thuộc tính line.separator của hệ thống. Các ký tự được mã hóa thành byte bằng bảng mã được chỉ định.

Tham số tùy chọn chỉ định cách tệp được tạo hoặc mở. Nếu không có tùy chọn nào thì phương thức này hoạt động như thể có các tùy chọn CREATE, TRUNCATE_EXISTING và WRITE. Nói cách khác, nó mở tệp để ghi, tạo tệp nếu nó không tồn tại hoặc ban đầu cắt một tệp thông thường hiện có đến kích thước 0. Phương thức đảm bảo rằng tệp được đóng khi tất cả các dòng đã được ghi ( hoặc lỗi I / O hoặc ngoại lệ thời gian chạy khác được đưa ra). Nếu xảy ra lỗi I / O thì nó có thể xảy ra sau khi tệp được tạo hoặc cắt bớt hoặc sau khi một số byte được ghi vào tệp.

Xin lưu ý. Tôi thấy mọi người đã trả lời với Java tích hợp sẵn Files.write, nhưng điều đặc biệt trong câu trả lời của tôi mà dường như không ai đề cập đến là phiên bản quá tải của phương thức lấy Iterable of CharSequence (ví dụ String), thay vì một byte[]mảng, do đó text.getBytes()không bắt buộc , đó là một chút sạch hơn tôi nghĩ.

Nếu bạn muốn giữ các ký tự trả về vận chuyển từ chuỗi thành một tệp ở đây là một ví dụ mã:

    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("\n", "\r\n");
            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);
        }

    });

Cách của tôi dựa trên luồng do chạy trên tất cả các phiên bản Android và nhu cầu sử dụng tài nguyên fectelling như URL / URI, mọi đề xuất đều được chào đón.

Theo như liên quan, các luồng (InputStream và OutputStream) truyền dữ liệu nhị phân, khi nhà phát triển viết một chuỗi thành luồng, trước tiên phải chuyển đổi nó thành byte hoặc nói cách khác là mã hóa nó.

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

Bạn có thể sử dụng ArrayList để đặt tất cả nội dung của TextArea cho ví dụ và gửi dưới dạng tham số bằng cách gọi lưu, vì người viết chỉ viết các dòng chuỗi, sau đó chúng tôi sử dụng dòng "for" để viết ArrayList của chúng tôi vào cuối chúng tôi sẽ là nội dung TextArea trong tệp txt. Nếu một cái gì đó không có ý nghĩa, tôi xin lỗi là dịch giả google và tôi không nói tiếng Anh.

Xem Windows Notepad, nó không phải lúc nào cũng nhảy dòng và hiển thị tất cả trong một dòng, sử dụng Wordpad ok.

private void SaveActionPerformed(java.awt.event.ActionEvent evt) {

    String NameFile = Name.getText();
    ArrayList< String > Text = new ArrayList< String >();

    Text.add(TextArea.getText());

    SaveFile(NameFile, Text);
}

public void SaveFile(String name, ArrayList< String> message) {

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