Comment enregistrer une chaîne dans un fichier texte à l'aide de Java?

En Java, j'ai du texte d'un champ de texte dans une variable de chaîne appelée "texte".

Comment puis-je enregistrer le contenu de la variable "texte" dans un fichier?

Si vous sortez simplement du texte, plutôt que des données binaires, ce qui suit fonctionnera:

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

Ensuite, écrivez-y votre chaîne, comme vous le feriez pour n'importe quel flux de sortie:

out.println(text);

Vous aurez toujours besoin d'une gestion des exceptions. N'oubliez pas d'appeler out.close()lorsque vous avez terminé d'écrire.

Si vous utilisez Java 7 ou une version ultérieure, vous pouvez utiliser "l' instruction try-with-resources " qui fermera automatiquement votre PrintStreamlorsque vous en aurez terminé (c'est-à-dire quitter le bloc) comme ceci:

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

Vous devrez toujours lancer explicitement le java.io.FileNotFoundExceptioncomme précédemment.

Apache Commons IO contient d'excellentes méthodes pour ce faire, en particulier FileUtils contient la méthode suivante:

static void writeStringToFile(File file, String data) 

qui vous permet d'écrire du texte dans un fichier en un seul appel de méthode:

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

Vous pouvez également envisager de spécifier l'encodage du fichier également.

Jetez un œil à l' API Java File

un exemple rapide:

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

Dans Java 7, vous pouvez le faire:

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

Il y a plus d'informations ici: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

Je viens de faire quelque chose de similaire dans mon projet. Utiliser FileWriter simplifiera une partie de votre travail. Et ici, vous pouvez trouver un joli tutoriel .

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

Utilisation FileUtils.writeStringToFile()depuis Apache Commons IO . Pas besoin de réinventer cette roue particulière.

Vous pouvez utiliser la modification du code ci-dessous pour écrire votre fichier à partir de la classe ou de la fonction qui gère le texte. On se demande pourtant pourquoi le monde a besoin d'un nouvel éditeur de texte ...

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

Dans Java 11, la java.nio.file.Filesclasse a été étendue par deux nouvelles méthodes utilitaires pour écrire une chaîne dans un fichier. La première méthode (voir JavaDoc ici ) utilise le jeu de caractères UTF-8 par défaut:

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

Et la deuxième méthode (voir JavaDoc ici ) permet de spécifier un jeu de caractères individuel:

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

Les deux méthodes ont un paramètre Varargs facultatif pour définir les options de gestion des fichiers (voir JavaDoc ici ). L'exemple suivant créerait un fichier inexistant ou ajouterait la chaîne à un fichier existant:

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

Je préfère me fier autant que possible aux bibliothèques pour ce type d'opération. Cela me rend moins susceptible d'omettre accidentellement une étape importante (comme l'erreur Wolfsnipes faite ci-dessus). Certaines bibliothèques sont suggérées ci-dessus, mais mon préféré pour ce genre de chose est Google Guava . Guava a une classe appelée Files qui fonctionne bien pour cette tâche:

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

Utilisez l'API Apache Commons IO. C'est simple

Utiliser l'API en tant que

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

Dépendance Maven

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

Si vous avez besoin de créer un fichier texte basé sur une seule chaîne:

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

Utilisez-le, il est très lisible:

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

Vous pouvez insérer cette méthode dans vos classes. Si vous utilisez cette méthode dans une classe avec une méthode principale, changez cette classe en statique en ajoutant le mot clé statique. Dans tous les cas, vous devrez importer java.io. * pour le faire fonctionner, sinon File, FileWriter et BufferedWriter ne seront pas reconnus.

Vous pouvez faire ceci:

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

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

Utilisation de org.apache.commons.io.FileUtils:

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

Si vous ne voulez que pousser un bloc de texte dans un fichier, cela le remplacera à chaque fois.

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

Cet exemple permet à l'utilisateur de sélectionner un fichier à l'aide d'un sélecteur de fichiers.

Il est préférable de fermer le scripteur / flux de sortie dans un bloc enfin, au cas où quelque chose se produirait

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

}

Je pense que la meilleure façon est d'utiliser 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));

Voir javadoc :

Écrivez des lignes de texte dans un fichier. Chaque ligne est une séquence de caractères et est écrite dans le fichier en séquence, chaque ligne se terminant par le séparateur de ligne de la plate-forme, comme défini par la propriété système line.separator. Les caractères sont codés en octets à l'aide du jeu de caractères spécifié.

Le paramètre options spécifie comment le fichier est créé ou ouvert. Si aucune option n'est présente, cette méthode fonctionne comme si les options CREATE, TRUNCATE_EXISTING et WRITE étaient présentes. En d'autres termes, il ouvre le fichier pour l'écriture, en créant le fichier s'il n'existe pas ou en tronquant initialement un fichier régulier existant à une taille de 0. La méthode garantit que le fichier est fermé lorsque toutes les lignes ont été écrites ( ou une erreur d'E / S ou une autre exception d'exécution est levée). Si une erreur d'E / S se produit, elle peut le faire une fois le fichier créé ou tronqué, ou après que certains octets ont été écrits dans le fichier.

Notez s'il vous plaît. Je vois que les gens ont déjà répondu avec Java intégré Files.write, mais ce qui est spécial dans ma réponse, que personne ne semble mentionner, c'est la version surchargée de la méthode qui prend un Iterable de CharSequence (c'est-à-dire une chaîne), au lieu d'un byte[]tableau, text.getBytes()n'est donc pas nécessaire , ce qui est un peu plus propre je pense.

Si vous souhaitez conserver les caractères de retour chariot de la chaîne dans un fichier, voici un exemple de code:

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

    });

Ma voie est basée sur le flux en raison de l'exécution sur toutes les versions d'Android et des besoins en ressources de collecte telles que l'URL / l'URI, toute suggestion est la bienvenue.

En ce qui concerne, les flux (InputStream et OutputStream) transfèrent des données binaires, lorsque le développeur va écrire une chaîne dans un flux, doit d'abord la convertir en octets, ou en d'autres termes l'encoder.

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

Vous pouvez utiliser ArrayList pour mettre tout le contenu de TextArea par exemple, et envoyer comme paramètre en appelant la sauvegarde, comme le rédacteur vient d'écrire des lignes de chaîne, puis nous utilisons ligne par ligne "pour" pour écrire notre ArrayList à la fin nous serons content TextArea dans le fichier txt. si quelque chose n'a pas de sens, je suis désolé est le traducteur google et moi qui ne parle pas anglais.

Regardez le Bloc-notes Windows, il ne saute pas toujours les lignes et affiche le tout sur une seule ligne, utilisez 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);     
    }   
}