Comment enregistrer une chaîne dans un fichier texte à l'aide de Java?
En Java, j'ai le texte d'un champ de texte dans une variable String appelée "text".
Comment puis-je sauvegarder le contenu de la variable "text" dans un fichier?
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 d'une gestion des exceptions, comme toujours. Assurez-vous 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 PrintStream lorsque vous en aurez terminé (par exemple, quittez le bloc) comme suit:
try (PrintWriter out = new PrintWriter("filename.txt")) {
out.println(text);
}
Vous devrez toujours explicitement lancer le Java.io.FileNotFoundException comme auparavant.
Apache Commons IO contient d'excellentes méthodes, notamment FileUtils contenant la méthode suivante:
static void writeStringToFile(File file, String data)
qui vous permet d'écrire du texte dans un fichier en une seule méthode:
FileUtils.writeStringToFile(new File("test.txt"), "Hello File");
Vous pouvez également envisager de spécifier le codage du fichier.
Jetez un coup d'oeil à la API de fichier Java
un exemple rapide:
try (PrintStream out = new PrintStream(new FileOutputStream("filename.txt"))) {
out.print(text);
}
Je viens de faire quelque chose de similaire dans mon projet. Utilisez FileWriter simplifiera une partie de votre travail. Et ici vous pouvez trouver Nice tutorial .
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)
{
}
}
En Java 7, vous pouvez faire ceci:
String content = "Hello File!";
String path = "C:/a.txt";
Files.write( Paths.get(path), content.getBytes(), StandardOpenOption.CREATE);
Plus d’informations ici: http://www.drdobbs.com/jvm/Java-se-7-new-file-io/231600403
Utilisez FileUtils.writeStringToFile() à partir de Apache Commons IO . Pas besoin de réinventer cette roue en particulier.
Vous pouvez utiliser le code ci-dessous pour modifier votre fichier, quelle que soit la classe ou la fonction manipulant 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 Apache Commons IO api. C'est 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 faire appel à des bibliothèques chaque fois que cela est possible pour ce type d'opération. Cela me rend moins susceptible d'omettre accidentellement une étape importante (comme l'erreur wolfsnipes faite plus haut). 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
}
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();
}
}
}
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 la clé statique Word. De toute façon, vous devrez importer Java.io. * pour que cela fonctionne, sinon File, FileWriter et BufferedWriter ne seront pas reconnus.
Vous pourriez 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 ;
}
};
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);
Utiliser 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 é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.
Dans Java 11, la classe Java.nio.file.Files a été étendue par deux nouvelles méthodes pour écrire une chaîne de caractères dans un fichier (voir JavaDoc ici et ici ). Dans le cas le plus simple, il s’agit maintenant d’un one-liner:
Files.writeString(Paths.get("somepath"), "some_string");
Avec le paramètre facultatif Varargs, vous pouvez définir d'autres options, telles que l'ajout d'un fichier existant ou la création automatique d'un fichier inexistant (voir JavaDoc ici ).
Il est préférable de fermer l'écriture/sortie en bloc final, juste au cas où quelque chose arriverait
finally{
if(writer != null){
try{
writer.flush();
writer.close();
}
catch(IOException ioe){
ioe.printStackTrace();
}
}
}
Je pense que le meilleur moyen 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é système line.separator. Les caractères sont codés en octets en utilisant le .__ spécifié. jeu de caractères.
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 CREATE, Les options TRUNCATE_EXISTING et WRITE sont présentes. En d'autres termes, il ouvre le fichier en écriture, crée le fichier s'il n'existe pas, ou tronquant initialement un fichier régulier existant à une taille de 0. Le Cette méthode garantit que le fichier est fermé lorsque toutes les lignes ont été écrit (ou une erreur d’entrée/sortie ou une autre exception d’exécution est levée). Si un Une erreur d'E/S se produit, il peut le faire après la création du fichier ou tronqué, ou après que quelques octets aient été écrits dans le fichier.
Notez s'il vous plaît. Je vois des gens qui 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 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 tableau byte[], donc text.getBytes() n'est pas obligatoire, ce qui est un peu plus propre, je pense.
Vous pouvez utiliser ArrayList pour mettre tout le contenu de TextArea par exemple, et l'envoyer en tant que 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 contenu TextArea dans un fichier txt. si quelque chose n'a pas de sens, je suis désolé, google translator et moi qui ne parle pas anglais.
Regardez le Bloc-notes Windows, il ne saute pas toujours de lignes et affiche tout en une, utilisez Wordpad ok.
saveActionPerformed (Java.awt.event.ActionEvent evt) privé void {
String NameFile = Name.getText();
ArrayList< String > Text = new ArrayList< String >();
Text.add(TextArea.getText());
SaveFile(NameFile, Text);
}
public void SaveFile (Nom de la chaîne, message ArrayList <String>) {
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);
}
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);
}
}
Mon chemin est basé sur le flux en raison de l’exécution sur toutes les versions d’Android et des besoins en ressources tels que les URL/URI, toute suggestion est la bienvenue.
En ce qui concerne concerné, 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;
}
Si vous souhaitez conserver les caractères de retour à la ligne 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);
}
});