Jak zapisać ciąg do pliku tekstowego za pomocą Java?

W Javie mam tekst z pola tekstowego w zmiennej String zwanej „tekstem”.

Jak mogę zapisać zawartość zmiennej „tekst” do pliku?

Jeśli po prostu wyprowadzasz tekst, a nie dane binarne, działają:

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

Następnie napisz do niego swój ciąg znaków, tak jak w przypadku dowolnego strumienia wyjściowego:

out.println(text);

Jak zawsze będziesz potrzebować obsługi wyjątków. Pamiętaj, aby zadzwonić out.close()po zakończeniu pisania.

Jeśli używasz Java 7 lub nowszej wersji, możesz użyć „instrukcji try-with-resources ”, która automatycznie zamknie twoją PrintStreamwersję po zakończeniu (tj. Wyjściu z bloku) w następujący sposób:

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

Nadal będziesz musiał wyraźnie rzucić, java.io.FileNotFoundExceptionjak poprzednio.

Apache Commons IO zawiera kilka świetnych metod, w szczególności FileUtils zawiera następującą metodę:

static void writeStringToFile(File file, String data) 

który pozwala pisać tekst do pliku w jednym wywołaniu metody:

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

Możesz również rozważyć określenie kodowania pliku.

Spójrz na API Java File API

szybki przykład:

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

W Javie 7 możesz to zrobić:

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

Więcej informacji tutaj: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

Właśnie zrobiłem coś podobnego w moim projekcie. Korzystanie z FileWriter uprości część zadania. I tutaj możesz znaleźć fajny samouczek .

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

Użyj FileUtils.writeStringToFile()z Apache Commons IO . Nie ma potrzeby wymyślania tego konkretnego koła.

Możesz użyć poniższego kodu modyfikacji, aby zapisać plik z dowolnej klasy lub funkcji, która obsługuje tekst. Można się jednak zastanawiać, dlaczego świat potrzebuje nowego edytora tekstu ...

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

W Javie 11java.nio.file.Files klasa została rozszerzona o dwie nowe metody użytkowych napisać ciąg do pliku. Pierwsza metoda (patrz JavaDoc tutaj ) używa domyślnie zestawu znaków UTF-8 :

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

Druga metoda (patrz JavaDoc tutaj ) pozwala określić indywidualny zestaw znaków:

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

Obie metody mają opcjonalny parametr Varargs do ustawiania opcji obsługi plików (patrz JavaDoc tutaj ). Poniższy przykład utworzyłby nieistniejący plik lub dołączył łańcuch do istniejącego:

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

W miarę możliwości wolę polegać na bibliotekach. To sprawia, że ​​mniej prawdopodobne jest, że przypadkowo pomijam ważny krok (jak pomyłka wilcze strzały zrobione powyżej). Niektóre biblioteki są sugerowane powyżej, ale moim ulubionym do tego rodzaju rzeczy jest Google Guava . Guava ma klasę o nazwie Pliki, która ładnie działa do tego zadania:

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

Użyj Apache Commons IO api. To proste

Użyj API jako

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

Zależność Maven

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

Jeśli potrzebujesz utworzyć plik tekstowy na podstawie jednego ciągu:

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

Użyj tego, jest bardzo czytelny:

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

Możesz wstawić tę metodę do swoich klas. Jeśli używasz tej metody w klasie z metodą główną, zmień tę klasę na statyczną, dodając słowo klucza statycznego. Tak czy inaczej, musisz zaimportować plik java.io. *, aby działał, w przeciwnym razie File, FileWriter i BufferedWriter nie zostaną rozpoznane.

Możesz to zrobić:

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

Używanie 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);
}

Korzystanie z org.apache.commons.io.FileUtils:

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

Jeśli zależy Ci tylko na wypchnięciu jednego bloku tekstu do pliku, spowoduje to zastąpienie go za każdym razem.

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

Ten przykład pozwala użytkownikowi wybrać plik za pomocą selektora plików.

Lepiej jest zamknąć moduł zapisujący / wyjściowy w ostatnim bloku, na wypadek, gdyby coś się wydarzyło

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

}

Myślę, że najlepszym sposobem jest użycie 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));

Zobacz javadoc :

Napisz wiersze tekstu do pliku. Każda linia jest sekwencją char i jest zapisywana do pliku w sekwencji, a każda linia kończy się separatorem linii platformy, zgodnie z definicją właściwości systemowej line.separator. Znaki są kodowane w bajtach przy użyciu określonego zestawu znaków.

Parametr options określa sposób tworzenia lub otwierania pliku. Jeśli nie ma żadnych opcji, ta metoda działa tak, jakby były dostępne opcje CREATE, TRUNCATE_EXISTING i WRITE. Innymi słowy, otwiera plik do zapisu, tworzenia pliku, jeśli nie istnieje, lub początkowego obcięcia istniejącego zwykłego pliku do rozmiaru 0. Metoda zapewnia zamknięcie pliku po zapisaniu wszystkich wierszy ( lub zgłaszany jest błąd we / wy lub inny wyjątek czasu wykonywania). Jeśli wystąpi błąd we / wy, może to zrobić po utworzeniu lub obcięciu pliku lub po zapisaniu do niego niektórych bajtów.

Proszę zanotować. Widzę, że ludzie już odpowiedzieli wbudowaną Javą Files.write, ale w mojej odpowiedzi szczególna rzecz, o której chyba nikt nie wspomina, to przeciążona wersja metody, która pobiera Iterable z CharSequence (tj. String) zamiast byte[]tablicy, dlatego text.getBytes()nie jest wymagana , co wydaje mi się nieco czystsze.

Jeśli chcesz zachować znaki powrotu karetki z łańcucha do pliku, oto przykład kodu:

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

    });

Mój sposób jest oparty na strumieniu ze względu na działanie na wszystkich wersjach Androida i potrzeby pobierania zasobów takich jak URL / URI, wszelkie sugestie są mile widziane.

Jeśli chodzi o strumienie, dane wejściowe (InputStream i OutputStream) przesyłają dane binarne, gdy programista zapisuje ciąg do strumienia, najpierw musi go przekonwertować na bajty lub innymi słowy, zakodować.

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

Możesz użyć ArrayList, aby umieścić całą zawartość TextArea dla przykładu, i wysłać jako parametr, wywołując save, ponieważ pisarz właśnie napisał linie ciągów, a następnie używamy „for” wiersz po wierszu, aby zapisać naszą ArrayList na końcu będziemy zawartość TextArea w pliku txt. jeśli coś nie ma sensu, przykro mi to tłumacz Google i ja, którzy nie mówię po angielsku.

Obejrzyj Notatnik Windows, nie zawsze przeskakuje on przez linie i pokazuje wszystko w jednym wierszu, użyj WordPada 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);     
    }   
}