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


699

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?

Réponses:


727

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.


4
@Justin, vous pouvez également transmettre un chemin absolu (par exemple, "/tmp/filename.txt") au constructeur FileOutputStream, pour enregistrer le fichier où vous le souhaitez
Jonik

7
Btw, cela pourrait être simplifié en utilisant les constructeurs de commodité que PrintStream possède depuis la version 1.5. Cela suffirait: PrintStream out = new PrintStream ("filename.txt");
Jonik

10
Besoin de fermer ce fichier à un moment donné ...? codecodex.com/wiki/ASCII_file_save#Java
JStrahl

2
Vous voulez utiliser try {} catch () {} enfin {}, où enfin {} vous fermez le fichier s'il n'est pas nul.
Benas

23
Dans java8, vous pouvez essayer (PrintStream ps = new PrintStream ("filename")) {ps.println (out); } cela se terminera pour vous
Anton Chikin

245

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.


10
Juste une correction mineure, le deuxième fragment devrait lire: FileUtils.writeStringToFile (nouveau fichier ("test.txt"), "Hello File");
pm_labs

3
Pour ceux d'entre nous qui préfèrent la goyave, cela peut aussi le faire .
Jonik

10
La fonction est maintenant obsolète, vous devez ajouter le jeu de caractères par défaut ->FileUtils.writeStringToFile(new File("test.txt"), "Hello File", forName("UTF-8"));
Paul Fournel

97

Jetez un œil à l' API Java File

un exemple rapide:

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

@ XP1 Je sais, c'est une grande amélioration. J'ai utilisé Lombok pour cela dans Java 6: allez-y @Cleanup new FileOutputStream(...)et vous avez terminé.
Jorn

6
N'oubliez pas d'appeler out.flush (); puis out.close ();
Alex Byrth

@AlexByrth pourquoi devrait-il?
Andrew Tobilko

1
Les fichiers volumineux sont enregistrés en arrière-plan (un autre fil) et prennent du temps à enregistrer. L'appel de flush () garantit que tout a été écrit sur la ligne suivante, synchronisant l'opération. Mais c'est facultatif , mais c'est une bonne pratique si vous manipulez des fichiers volumineux, comme des journaux.
Alex Byrth

1
Notez que out.close () vide déjà le flux, ce qui signifie qu'il n'est pas nécessaire d'appeler out.flush ().
hjk321

90

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


3
Au cas où quelqu'un se demanderait plus tard, l'encodage serait le standard de la plate-forme.
Haakon Løtveit

5
content.getBytes(StandardCharsets.UTF_8)peut être utilisé pour définir explicitement l'encodage.
John29

1
Notez que StandardOpenOption.CREATE n'est pas la valeur par défaut StandardOpenOption.CREATE et StandardOpenOption.TRUNCATE_EXISTING est la valeur par défaut. Pour utiliser la valeur par défaut, supprimez simplement le troisième paramètre.
Tinus Tate

Veuillez voir le commentaire de Tinus Tate! Quel est le processus pour modifier cet exemple? Je me demande combien de milliers de personnes ont pris cet exemple tel quel pour constater qu'elles ont des résultats inattendus lorsqu'elles écrasent un fichier avec une chaîne plus courte. Comme l'indique Tinus, TRUNCATE_EXISTING est crucial, sauf si vous comprenez parfaitement et avez une raison réelle de ne pas vouloir tronquer le fichier existant lors du remplacement par une chaîne plus courte.
jch

1
Dans java 11, vous pouvez simplement mettre une chaîne comme deuxième paramètre! Hourra!
Dennis Glot

78

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

4
En supprimant tous les try / catch et en simplifiant, je peux également le faire en une seule ligne simplement en faisant: (new BufferedWriter (new FileWriter (filename))). Write (str);
Artem Barger le

6
Alors, montrez votre solution simple et agréable. Je serais ravi d'apprendre à mieux le faire.
Artem Barger le

4
Ignorez les trolls ... ils critiquent toujours sans proposer leur propre solution. Merci de m'avoir sauvé de l'écriture de mon propre code / du téléchargement d'une bibliothèque supplémentaire et de l'introduction de la dépendance ...
nikib3ro

1
Il semble que .close()cela ne lance pas (au moins en Java 7?), Le dernier trycatch est-il peut-être redondant?
Kos

16
Avaler des exceptions comme ça va vous rendre la vie difficile quand des exceptions se produisent vraiment. Vous devriez au moins les retourner:throw new RuntimeException(e);
Roger Keays

65

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


20
Je ne pouvais pas être plus en désaccord. Ces bibliothèques sont là, donc nous n'introduisons pas de bogues subtils dans une solution aussi simple.
skaffman

3
Non, évidemment pas. Je ne suis pas d'accord que votre solution pourrait ne pas être la première chose que je lancerais à quelqu'un qui est un programmeur Java débutant. Vous ne dites pas que vous n'avez jamais écrit une telle chose, n'est-ce pas?
duffymo le

8
Je l'ai, oui, mais c'est avant que je trouve commun-io. Depuis que je l'ai trouvé, je n'ai jamais écrit ce genre de choses à la main, même dans un projet à classe unique. Si je l'avais su dès le premier jour, je l'aurais utilisé dès le premier jour.
skaffman

5
Exactement, mais vous êtes un développeur expérimenté. Votre biographie indique que vous êtes un utilisateur de JBOSS / Spring, mais vous n'auriez certainement pas été à la hauteur de l'un ou de l'autre lors de votre premier effort "Hello, World". Je ne suis pas en désaccord avec la bonne utilisation des bibliothèques. Je dis que les gens qui tentent une langue pour la première fois devraient essayer de la connaître au fond, même si cela signifie faire des choses qu'ils écarteront plus tard lorsqu'ils seront expérimentés et mieux informés.
duffymo

2
J'ai implémenté cela sans commons et j'ai obtenu une exception moins qu'évidente. J'ai ensuite implémenté cela en utilisant des communs et cela m'a dit exactement ce qui n'allait pas. Morale de l'histoire: pourquoi vivre dans les âges sombres si vous n'êtes pas obligé?
SilentNot

22

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

2
Cela ne ferme pas le fichier en cas d'exception.
Tom Hawtin - tackline

1
@JanusTroelsen: En cas de rejet, citez la déclaration try-with-resources .
trashgod

22

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

13

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
}

2
Si vous utilisez Guava, il y en a aussi Charsets.UTF-8.
florian

2
@florian: C'est en Charsets.UTF_8fait
Tim Büthe

Le dossier parent doit exister. Exemple: destination.mkdirs ().
AlikElzin-kilaka

2
Files.write (CharSequence de, File to, Charset charset) est obsolète dans goyave 26.0.
Donald Duck

Alternative moderne à la goyave pour Files.write obsolète: Files.asCharSink(file, charset).write(text)
Vadzim

12

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>

12

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

Files.write (chemin, octet []) utilisera le codage UTF-8. String.getBytes () utilise l'encodage de plate-forme par défaut. C'est donc un problème potentiel. Utilisez string.getBytes (StandardCharsets.UTF_8)!
rmuller

11

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

C'est aussi une copie d'une réponse existante. : c
james.garriss

2
désolé mais je n'ai pas inventé java8, je ne suis pas le seul à utiliser cette ligne. mais ce n'est pas une copie passée d'autres réponses à la même question
Ran Adler

10
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.


10

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

10

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

Un mot pour le sage - cela créera un nouveau fichier s'il n'est pas là, mais écrasera les caractères du fichier existant s'il l'est. Si les nouvelles données sont plus petites, cela signifie que vous créerez probablement un fichier corrompu. Demandez-moi comment je sais!
Chris Rae

Ok, comment tu sais?
ojblass

Il suffit alors Files.write(targetPath, bytes);de remplacer le fichier. Cela fonctionnera comme prévu.
BullyWiiPlaza

8

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

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

6

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.


@Eric Leschinski: merci d'avoir rendu ma réponse plus professionnelle (j'ai également supposé que c'était exactement ce que le PO voulait, car c'est ce que la plupart des gens veulent, juste vider le texte et le remplacer)
bhathiya-perera

2
Une fois que la question d'origine a été répondue et que le PO est satisfait et a disparu depuis longtemps, des pages comme celle-ci ne servent que d'artefact utile aux personnes qui arrivent ici à partir d'une recherche Google. J'ai atterri sur cette page afin de créer un mini-appendeur de texte dans un fichier. Il est donc bon de parler à l'ensemble du public plutôt qu'à l'OP après que l'OP a évolué.
Eric Leschinski

3

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

1
encore mieux: utilisez try-with-resources
Janus Troelsen

Oui, @JanusTroelsen a raison, mieux utiliser L'instruction try-with-resources docs.oracle.com/javase/tutorial/essential/exceptions/…

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

}


1
Bien que cet extrait de code puisse être la solution, y compris une explication aide vraiment à améliorer la qualité de votre message. N'oubliez pas que vous répondrez à la question pour les lecteurs à l'avenir, et ces personnes pourraient ne pas connaître les raisons de votre suggestion de code.
Johan

close () ne peut jamais être appelé. Veuillez améliorer votre réponse en ajoutant la gestion appropriée des cas d'erreur.
Boris Brodski

0

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.


0

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

    });

-1

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

1
Veuillez ajouter la gestion des cas d'erreur appropriée en fermant toutes les ressources ouvertes et en propageant les exceptions
Boris Brodski

Pourriez-vous partager les cas de gestion de code comme vous l'avez recommandé, merci.
牟家宏

-1

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

Vous pouvez laisser un tas de ressources ouvertes. C'est une mauvaise pratique, s'il vous plaît, ne faites pas ça.
Boris Brodski
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.