Hoe sla ik een string op in een tekstbestand met Java?

In Java heb ik tekst uit een tekstveld in een String-variabele met de naam “text”.

Hoe kan ik de inhoud van de variabele “tekst” in een bestand opslaan?


Antwoord 1, autoriteit 100%

Als u alleen tekst uitvoert in plaats van binaire gegevens, werkt het volgende:

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

Schrijf er vervolgens je String naar toe, net zoals je zou doen naar elke uitvoerstroom:

out.println(text);

Je zult zoals altijd uitzonderingen moeten afhandelen. Zorg ervoor dat je out.close()belt als je klaar bent met schrijven.

Als u Java 7 of hoger gebruikt, kunt u de “gebruiken try-with-resources-instructie” die uw PrintStreamautomatisch sluit als u klaar bent (dwz het blok verlaat), zoals:

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

Je moet nog steeds expliciet de java.io.FileNotFoundExceptiongooien zoals eerder.


Antwoord 2, autoriteit 34%

Apache Commons IObevat enkele geweldige methoden om dit te doen, met name FileUtils bevat de volgende methode:

static void writeStringToFile(File file, String data) 

waarmee je tekst naar een bestand kunt schrijven in één methodeaanroep:

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

U kunt ook overwegen om ook de codering voor het bestand op te geven.


Antwoord 3, autoriteit 15%

In Java 7 kunt u dit doen:

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

Hier vindt u meer informatie:
http://www.drdobbs.com/jvm/java -se-7-new-file-io/231600403


Antwoord 4, autoriteit 14%

Bekijk de Java File API

een snel voorbeeld:

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

Antwoord 5, autoriteit 10%

Ik heb net iets soortgelijks gedaan in mijn project. Gebruik FileWritervereenvoudigt een deel van uw functie. En hier vind je een leuke zelfstudie.

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

Antwoord 6, autoriteit 9%

Gebruik FileUtils.writeStringToFile()van Apache Commons IO. Het is niet nodig om dit specifieke wiel opnieuw uit te vinden.


Antwoord 7, autoriteit 5%

In Java 11is de klasse java.nio.file.Filesuitgebreid met twee nieuwe hulpprogramma-methoden om een string in een bestand te schrijven. De eerste methode (zie JavaDoc hier) gebruikt de tekenset UTF-8 als standaard:

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

En de tweede methode (zie JavaDoc hier) staat toe om een individuele tekenset te specificeren:

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

Beide methoden hebben een optionele Varargs-parameter voor het instellen van opties voor bestandsverwerking (zie JavaDoc hier). In het volgende voorbeeld zou een niet-bestaand bestand worden gemaakt of de tekenreeks aan een bestaand bestand worden toegevoegd:

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

Antwoord 8, autoriteit 3%

U kunt de onderstaande code wijzigen om uw bestand te schrijven vanuit elke klasse of functie die de tekst verwerkt. Je vraagt je echter af waarom de wereld een nieuwe teksteditor nodig heeft…

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

Antwoord 9, autoriteit 2%

Ik vertrouw bij voorkeur zoveel mogelijk op bibliotheken voor dit soort operaties. Hierdoor is de kans kleiner dat ik per ongeluk een belangrijke stap oversla (zoals de fout die wolfsnipes hierboven maakte). Sommige bibliotheken worden hierboven voorgesteld, maar mijn favoriet voor dit soort dingen is Google Guava. Guava heeft een klasse met de naam Bestandenwat goed werkt voor deze taak:

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

Antwoord 10, autoriteit 2%

Gebruik de Apache Commons IO-API. Het is eenvoudig

Gebruik API als

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

Maven Dependency

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

Antwoord 11, autoriteit 2%

Gebruik dit, het is zeer leesbaar:

import java.nio.file.Files;
import java.nio.file.Paths;
Files.write(Paths.get(path), lines.getBytes(), StandardOpenOption.WRITE);

Antwoord 12, autoriteit 2%

Java 7gebruiken:

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

Antwoord 13, autoriteit 2%

Als u een tekstbestand wilt maken op basis van één enkele tekenreeks:

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

Antwoord 14

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

Je kunt deze methode in je lessen invoegen. Als u deze methode gebruikt in een klasse met een hoofdmethode, wijzigt u deze klasse in statisch door het statische sleutelwoord toe te voegen. Hoe dan ook, je moet java.io.* importeren om het te laten werken, anders worden File, FileWriter en BufferedWriter niet herkend.


Antwoord 15

Je zou dit kunnen doen:

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

Antwoord 16

Org.apache.commons.io.FileUtils gebruiken:

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

Antwoord 17

Als je maar één blok tekst naar het bestand wilt pushen, zal dit het elke keer overschrijven.

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

In dit voorbeeld kan de gebruiker een bestand selecteren met behulp van een bestandskiezer.


Antwoord 18

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

Antwoord 19

Het is beter om de schrijver/outputstream in een definitief blok te sluiten, voor het geval er iets gebeurt

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

Antwoord 20

In principe hetzelfde antwoord als hier, maar makkelijk te kopiëren/plakken, en het werkt gewoon 😉

 import java.io.FileWriter;
  public void saveToFile(String data, String filename) {
    try (
      FileWriter fw = new FileWriter(filename)) {
      fw.write(data);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

Antwoord 21

Ik denk dat de beste manier is om 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));

Zie javadoc:

Schrijf regels tekst naar een bestand. Elke regel is een tekenreeks en is
achtereenvolgens naar het bestand geschreven waarbij elke regel wordt afgesloten met de
lijnscheidingsteken van het platform, zoals gedefinieerd door de systeemeigenschap
lijn.separator. Tekens worden gecodeerd in bytes met behulp van de opgegeven
tekenset.

De parameter options geeft aan hoe het bestand wordt gemaakt of geopend.
Als er geen opties aanwezig zijn, werkt deze methode alsof de CREATE,
TRUNCATE_EXISTING en WRITE-opties zijn aanwezig. Met andere woorden, het is
opent het bestand om te schrijven, maakt het bestand als het niet bestaat, of
aanvankelijk afkappen van een bestaand normaal bestand tot een grootte van 0. De
methode zorgt ervoor dat het bestand wordt gesloten als alle regels zijn
geschreven (of er wordt een I/O-fout of andere runtime-uitzondering gegenereerd). Als een
I/O-fout optreedt, kan dit gebeuren nadat het bestand is gemaakt of
afgekapt, of nadat enkele bytes naar het bestand zijn geschreven.

Let op. Ik zie dat mensen al hebben geantwoord met Java’s ingebouwde Files.write, maar wat speciaal is in mijn antwoord dat niemand lijkt te noemen, is de overbelaste versie van de methode die een Iterable van CharSequence (dwz String) nodig heeft. , in plaats van een byte[]array, dus text.getBytes()is niet vereist, wat een beetje schoner is denk ik.


Antwoord 22

Als u de regelteruglooptekens uit de tekenreeks in een bestand wilt bewaren
hier is een codevoorbeeld:

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

Antwoord 23

Mijn manier is gebaseerd op stream vanwege het draaien op alle Android-versies en de behoefte aan informatiebronnen zoals URL/URI, elke suggestie is welkom.

Wat betreft, streams (InputStream en OutputStream) dragen binaire gegevens over, wanneer de ontwikkelaar een string naar een stream gaat schrijven, deze eerst naar bytes moet converteren of met andere woorden moet coderen.

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

Antwoord 24

Je kunt de ArrayList gebruiken om bijvoorbeeld alle inhoud van de TextArea te plaatsen en als parameter te verzenden door de save aan te roepen, aangezien de schrijver zojuist stringregels heeft geschreven, dan gebruiken we de “for” regel voor regel om onze ArrayList te schrijven uiteindelijk zullen we de inhoud TextArea in txt-bestand. als er iets niet klopt, het spijt me is google vertaler en ik die geen Engels spreken.

Bekijk het Windows Kladblok, het springt niet altijd naar regels en toont alles in één regel, gebruik 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);     
    }   
}

Other episodes