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

Si vous produisez 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 besoin de la gestion des exceptions, comme toujours. Assurez-vous d'appeler out.close() lorsque vous avez fini d'écrire.

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

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

Vous devrez toujours lancer explicitement le java.io.FileNotFoundException comme avant.

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

Jetez un oeil à la API de fichier Java

Un exemple rapide:

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

J'ai juste fait quelque chose de similaire dans mon projet. Utilisez FileWriter simplifiera une partie de votre travail. Et ici vous pouvez trouver bon 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)
    {
    }
}

Dans Java 7, vous pouvez faire ceci:

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

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

Utilisez FileUtils.writeStringToFile()depuis Apache Commons IO. Pas besoin de réinventer cette roue.

Vous pouvez utiliser le modifier le code ci-dessous pour écrire votre fichier à partir de la classe ou de la fonction qui gère le texte. On se demande cependant 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();
        }
    }
}

Utilisez l'api Apache Commons IO. Son simple

Utiliser l'API comme

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

Dépendance maven

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

Je préfère m'appuyer sur les bibliothèques autant que possible pour ce genre 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 Goyave. 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
}

Dans le cas où 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();
        }
    }
}

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, modifiez cette classe en statique en ajoutant le mot clé statique. De toute façon vous devrez importer java.io. * pour le faire fonctionner sinon File, FileWriter et BufferedWriter ne seront pas reconnus.

Utilisez ceci, il est très lisible:

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

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

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 vous souciez que de pousser un bloc de texte dans un fichier, cela l'écrasera à 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 fichier.

Il est préférable de fermer le writer / outputstream dans un bloc finally, juste au cas où quelque chose se produirait

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

Vous pouvez utiliser la ArrayList pour mettre tout le contenu de la zone de texte par exemple, et envoyer en paramètre en appelant la sauvegarde, car l'écrivain vient d'écrire des lignes de chaîne, puis nous utilisons le "for" ligne par ligne 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 google translator et moi qui ne parle pas anglais.

Regardez le bloc-notes Windows, il ne saute pas toujours les lignes, et montre tout en une seule ligne, utilisez Wordpad OK.

Vide privé SaveActionPerformed(java.awt.événement.EVT) {

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

Text.add(TextArea.getText());

SaveFile(NameFile, Text);

}

Public void SaveFile(nom de chaîne, ArrayList 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);        

}

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:

Écrire des lignes de texte dans un fichier. Chaque ligne est une séquence de caractères et est écrit dans le fichier en séquence avec chaque ligne terminée par le séparateur de ligne de la plate-forme, tel que défini par la propriété system ligne.séparateur. Les caractères sont codés en octets à l'aide du jeu de caractères.

Le paramètre options spécifie comment le fichier est créé ou ouvert. Si aucune option n'est présente ensuite, cette méthode fonctionne comme si la CRÉATION, TRUNCATE_EXISTING, et les options d'ÉCRITURE sont présentes. En d'autres termes, il ouvre le fichier pour l'écriture, la création du fichier s'il n'existe pas, ou tronquer initialement un fichier régulier existant à une taille de 0. Le méthode garantit que le fichier est fermé lorsque toutes les lignes ont été écrit (ou une erreur d'E/S ou une autre exception d'exécution est levée). Si un Une erreur d'E/S se produit alors il peut le faire après la création du fichier ou tronqué, ou après que certains octets ont été écrit dans le fichier.

Veuillez noter. Je vois que les gens ont déjà répondu avec le Files.write intégré de Java, 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 Itérable de CharSequence (c'est-à-dire String), au lieu d'un tableau byte[], donc text.getBytes() n'est pas requis, ce qui est

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

    });