Comment créer un fichier et y écrire en Java?

1383

Quelle est la manière la plus simple de créer et d'écrire dans un fichier (texte) en Java?

Drew Johnson
la source

Réponses:

1735

Notez que chacun des exemples de code ci-dessous peut lancer IOException. Les blocs try / catch / finally ont été omis par souci de concision. Consultez ce didacticiel pour plus d'informations sur la gestion des exceptions.

Notez que chacun des exemples de code ci-dessous écrasera le fichier s'il existe déjà

Création d'un fichier texte:

PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8");
writer.println("The first line");
writer.println("The second line");
writer.close();

Création d'un fichier binaire:

byte data[] = ...
FileOutputStream out = new FileOutputStream("the-file-name");
out.write(data);
out.close();

Les utilisateurs de Java 7+ peuvent utiliser la Filesclasse pour écrire dans des fichiers:

Création d'un fichier texte:

List<String> lines = Arrays.asList("The first line", "The second line");
Path file = Paths.get("the-file-name.txt");
Files.write(file, lines, StandardCharsets.UTF_8);
//Files.write(file, lines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);

Création d'un fichier binaire:

byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);
Michael
la source
58
Il convient de noter que PrintWriter tronquera la taille du fichier à zéro si le fichier existe déjà
Covar
34
PrintWriter peut être (et est souvent) utilisé, mais n'est pas (conceptuellement) la bonne classe pour le travail. D'après la documentation: "PrintWriter prints formatted representations of objects to a text-output stream. "la réponse de Bozho est plus correcte, même si elle semble lourde (vous pouvez toujours l'envelopper dans une méthode utilitaire).
leonbloy
14
Alors, où le fichier texte sera-t-il créé après la création de l'application et son utilisation sur un autre PC puisque nous n'avons pas donné le chemin?
Marlon Abeykoon
13
@MarlonAbeykoon Bonne question. La réponse est qu'il créera le fichier texte dans le répertoire de travail . Le répertoire de travail est le répertoire à partir duquel vous exécutez votre programme. Par exemple, si vous exécutez votre programme à partir de la ligne de commande, le répertoire de travail sera le répertoire dans lequel vous vous trouvez à ce moment (sous Linux, tapez "pwd" pour voir le répertoire de travail actuel). Ou, si je double-clique sur un fichier JAR sur mon bureau pour l'exécuter, le répertoire de travail sera le bureau.
Michael
8
writer.close()devrait être dans un bloc enfin
Thierry
416

En Java 7 et supérieur:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(
              new FileOutputStream("filename.txt"), "utf-8"))) {
   writer.write("something");
}

Il existe cependant des utilitaires utiles pour cela:

Notez également que vous pouvez utiliser a FileWriter, mais il utilise l'encodage par défaut, ce qui est souvent une mauvaise idée - il est préférable de spécifier explicitement l'encodage.

Vous trouverez ci-dessous la réponse originale antérieure à Java 7


Writer writer = null;

try {
    writer = new BufferedWriter(new OutputStreamWriter(
          new FileOutputStream("filename.txt"), "utf-8"));
    writer.write("Something");
} catch (IOException ex) {
    // Report
} finally {
   try {writer.close();} catch (Exception ex) {/*ignore*/}
}

Voir aussi: Lecture, écriture et création de fichiers (inclut NIO2).

Bozho
la source
5
@leonbloy Je sais que c'est un vieux commentaire, mais si quelqu'un le voit, cela vous dérangerait-il d'expliquer pourquoi ce n'est pas "toujours bénéfique"? Au moins ici, il est dit "top efficace" docs.oracle.com/javase/1.5.0/docs/api/java/io/…
Juan
14
On dirait que l'écrivain n'a pas de méthode writeln (). Il n'a que write ()
YankeeWhiskey
10
Si vous changez le type d'écrivain en BufferedWriter (ce qu'il est en fait), vous pouvez utiliser writer.newLine ()
Niek
4
Il ne semble pas juste d'avoir un try / catch dans un enfin. Je connais la raison, mais cela ressemble à une odeur de code.
ashes999
4
@Trengot Oui. L'appel close()sur n'importe quel flux enroulé autour d'un autre fermera également tous les flux internes.
Fund Monica's Lawsuit
132

Si vous avez déjà le contenu que vous souhaitez écrire dans le fichier (et non généré à la volée), l' java.nio.file.Filesajout dans Java 7 dans le cadre des E / S natives fournit le moyen le plus simple et le plus efficace pour atteindre vos objectifs.

Fondamentalement, la création et l'écriture dans un fichier se fait sur une seule ligne, en plus un simple appel de méthode !

L'exemple suivant crée et écrit dans 6 fichiers différents pour montrer comment il peut être utilisé:

Charset utf8 = StandardCharsets.UTF_8;
List<String> lines = Arrays.asList("1st line", "2nd line");
byte[] data = {1, 2, 3, 4, 5};

try {
    Files.write(Paths.get("file1.bin"), data);
    Files.write(Paths.get("file2.bin"), data,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
    Files.write(Paths.get("file3.txt"), "content".getBytes());
    Files.write(Paths.get("file4.txt"), "content".getBytes(utf8));
    Files.write(Paths.get("file5.txt"), lines, utf8);
    Files.write(Paths.get("file6.txt"), lines, utf8,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
} catch (IOException e) {
    e.printStackTrace();
}
icza
la source
Bien fait. J'aime l'exemple file5 et file6. Pour tester file6, assurez-vous d'exécuter le programme deux fois, puis vous le verrez ajouter à nouveau les lignes.
tazboy
76
public class Program {
    public static void main(String[] args) {
        String text = "Hello world";
        BufferedWriter output = null;
        try {
            File file = new File("example.txt");
            output = new BufferedWriter(new FileWriter(file));
            output.write(text);
        } catch ( IOException e ) {
            e.printStackTrace();
        } finally {
          if ( output != null ) {
            output.close();
          }
        }
    }
}
Eric Petroelje
la source
18
Ne serait-il pas préférable de mettre output.close () dans un bloc finally?
qed
7
Un simple code ne peut jamais constituer ici une réponse. Vous devez expliquer.
Marquis de Lorne
7
en fait, cela ne se compilera pas, output.close()lance IOException
Bob Yoplait
43

Voici un petit exemple de programme pour créer ou écraser un fichier. C'est la version longue donc elle peut être comprise plus facilement.

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class writer {
    public void writing() {
        try {
            //Whatever the file path is.
            File statText = new File("E:/Java/Reference/bin/images/statsTest.txt");
            FileOutputStream is = new FileOutputStream(statText);
            OutputStreamWriter osw = new OutputStreamWriter(is);    
            Writer w = new BufferedWriter(osw);
            w.write("POTATO!!!");
            w.close();
        } catch (IOException e) {
            System.err.println("Problem writing to the file statsTest.txt");
        }
    }

    public static void main(String[]args) {
        writer write = new writer();
        write.writing();
    }
}
Draeven
la source
39

Un moyen très simple de créer et d'écrire dans un fichier en Java:

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;

public class CreateFiles {

    public static void main(String[] args) {
        try{
            // Create new file
            String content = "This is the content to write into create file";
            String path="D:\\a\\hi.txt";
            File file = new File(path);

            // If file doesn't exists, then create it
            if (!file.exists()) {
                file.createNewFile();
            }

            FileWriter fw = new FileWriter(file.getAbsoluteFile());
            BufferedWriter bw = new BufferedWriter(fw);

            // Write in file
            bw.write(content);

            // Close connection
            bw.close();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
}
Anuj Dhiman
la source
7
Le File.exists()/createNewFile()code ici est à la fois inutile et inutile. Le système d'exploitation doit déjà faire exactement la même chose lors de sa new FileWriter()création. Vous forcez tout cela à se produire deux fois.
Marquis de Lorne
1
File.exists () / createNewFile () n'est pas inutile et inutile. Je cherchais un moyen d'exécuter du code différent selon que le fichier est déjà présent ou non. Ce fut très utile.
KirstieBallance
2
J'ai utilisé cette méthode mais vous devez savoir qu'elle écrase le fichier à chaque fois. Si vous souhaitez l'ajouter au cas où le fichier existe, vous devez instancier FileWritercomme suit:new FileWriter(file.getAbsoluteFile(),true)
Adelin
2
C'est à la fois inutile et inutile, pour la raison que j'ai indiquée. Vous provoquez deux tests d'existence, deux créations et une suppression: et vous n'exécutez pas de code différent ici selon que le fichier est déjà présent ou non.
Marquis de Lorne
34

Utilisation:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) {
    writer.write("text to write");
} 
catch (IOException ex) {
    // Handle me
}  

L'utilisation try()fermera automatiquement le flux. Cette version est courte, rapide (tamponnée) et permet de choisir l'encodage.

Cette fonctionnalité a été introduite dans Java 7.

icl7126
la source
5
Il convient de noter qu'il s'agit d'une fonction Java 7, donc ne fonctionnera pas dans les versions précédentes de Java.
Dan Temple
3
On pourrait utiliser la "constante" StandardCharsets.UTF_8au lieu de la chaîne "utf-8" (cela évite les fautes de frappe) ...new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8)...- java.nio.charset.StandardCharsetsest introduit dans java 7
Ralph
20

Ici, nous entrons une chaîne dans un fichier texte:

String content = "This is the content to write into a file";
File file = new File("filename.txt");
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close(); // Be sure to close BufferedWriter

Nous pouvons facilement créer un nouveau fichier et y ajouter du contenu.

iKing
la source
Notez que la fermeture de BufferedWriter est suffisante car elle prend également en charge la fermeture de FileWriter.
rbaleksandar
17

Étant donné que l'auteur n'a pas précisé s'ils ont besoin d'une solution pour les versions Java qui ont été EoL (par Sun et IBM, et ce sont techniquement les JVM les plus répandues), et en raison du fait que la plupart des gens semblent avoir répondu à la question de l'auteur avant qu'il ne soit précisé qu'il s'agit d'un fichier texte (non binaire) , j'ai décidé d'apporter ma réponse.


Tout d'abord, Java 6 a généralement atteint la fin de sa vie, et comme l'auteur n'a pas précisé qu'il a besoin d'une compatibilité héritée, je suppose que cela signifie automatiquement Java 7 ou supérieur (Java 7 n'est pas encore en fin de vie par IBM). Ainsi, nous pouvons regarder à droite le didacticiel d'E / S de fichiers: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Avant la version Java SE 7, la classe java.io.File était le mécanisme utilisé pour les E / S de fichiers, mais elle présentait plusieurs inconvénients.

  • De nombreuses méthodes ne lançaient pas d'exceptions en cas d'échec, il était donc impossible d'obtenir un message d'erreur utile. Par exemple, si une suppression de fichier échouait, le programme recevrait un "échec de suppression" mais ne saurait pas si c'était parce que le fichier n'existait pas, l'utilisateur n'avait pas les autorisations ou il y avait un autre problème.
  • La méthode de renommage ne fonctionnait pas de manière cohérente sur toutes les plateformes.
  • Il n'y avait pas vraiment de support pour les liens symboliques.
  • Une meilleure prise en charge des métadonnées était souhaitée, comme les autorisations de fichier, le propriétaire du fichier et d'autres attributs de sécurité. L'accès aux métadonnées des fichiers était inefficace.
  • De nombreuses méthodes de fichier n'ont pas évolué. La demande d'une grande liste de répertoires sur un serveur peut entraîner un blocage. Les répertoires volumineux peuvent également provoquer des problèmes de ressources mémoire, entraînant un déni de service.
  • Il n'était pas possible d'écrire du code fiable qui pourrait parcourir récursivement une arborescence de fichiers et répondre de manière appropriée s'il y avait des liens symboliques circulaires.

Eh bien, cela exclut java.io.File. Si un fichier ne peut pas être écrit / ajouté, vous ne pourrez peut-être même pas savoir pourquoi.


Nous pouvons continuer à regarder le tutoriel: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Si vous avez toutes les lignes que vous écrirez (ajouterez) au fichier texte à l'avance , l'approche recommandée est https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# write-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption ...-

Voici un exemple (simplifié):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, StandardCharsets.UTF_8);

Un autre exemple (en annexe):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);

Si vous souhaitez écrire le contenu du fichier au fur et à mesure : https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#newBufferedWriter-java.nio.file.Path-java .nio.charset.Charset-java.nio.file.OpenOption ...-

Exemple simplifié (Java 8 ou supérieur):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
    writer.append("Zero header: ").append('0').write("\r\n");
    [...]
}

Un autre exemple (en annexe):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) {
    writer.write("----------");
    [...]
}

Ces méthodes nécessitent un effort minimal de la part de l'auteur et doivent être préférées à toutes les autres lors de l'écriture dans des fichiers [texte].

afk5min
la source
«Si un fichier ne peut pas être écrit / ajouté, vous ne pourrez peut-être même pas savoir pourquoi» n'est pas correct. Vous saurez exactement pourquoi, à partir du texte de ce FileNotFoundExceptionqui est lancé lorsque l'opération échoue.
Marquis de Lorne
"De nombreuses méthodes ne lançaient pas d'exceptions en cas d'échec, il était donc impossible d'obtenir un message d'erreur utile. Par exemple, si une suppression de fichier échouait, le programme recevrait un" échec de suppression "mais ne saurait pas si c'était parce que le fichier n'existait pas, l'utilisateur n'avait pas d'autorisations ou il y avait un autre problème. "
afk5min
Lisez ce que j'ai écrit. « Si un fichier ne peut pas être écrit / ajouté, vous ne pourrez peut-être même pas obtenir un message d'erreur utile» est incorrect, pour la raison que j'ai indiquée, et le reste. Vous changez de sujet. Votre propre sujet.
Marquis de Lorne
J'examinerai les implémentations intégrées pour les systèmes de fichiers typiques (qui seraient dans OpenJDK, mais je n'ai aucune raison de penser que cette partie serait différente dans Oracle JDK propriétaire, ou significativement différente dans IBM JDK propriétaire, entre autres) et mise à jour ma réponse sur la base de ces résultats. Votre commentaire est logique - simplement parce que «de nombreuses méthodes» peuvent avoir des problèmes, l'auteur a clairement déclaré que ce n'est que l'opération d'écriture / d'ajout au fichier qui leur tient à cœur.
afk5min
Il en est ainsi parce qu'aucune des méthodes que vous appelez ne parvient à lever des exceptions appropriées contenant des messages d'erreur appropriés. Si vous avez un contre-exemple qui soutient votre affirmation, c'est à vous de le fournir.
Marquis de Lorne
16

Si vous souhaitez vivre une expérience relativement indolore, vous pouvez également consulter le package Apache Commons IO , plus précisément la FileUtilsclasse .

N'oubliez jamais de vérifier les bibliothèques tierces. Joda-Time pour la manipulation de date, Apache Commons LangStringUtils pour les opérations de chaîne courantes et ainsi de suite peut rendre votre code plus lisible.

Java est un excellent langage, mais la bibliothèque standard est parfois un peu bas niveau. Puissant, mais de bas niveau néanmoins.

extranéon
la source
1
La méthode d'écriture de fichiers la plus simple en FileUtilsest static void write(File file, CharSequence data). Exemple d' utilisation: import org.apache.commons.io.FileUtils; FileUtils.write(new File("example.txt"), "string with data");. FileUtilsa également writeLines, qui prend une Collectiondes lignes.
Rory O'Kane
12

Si pour une raison quelconque vous voulez séparer l'acte de créer et d'écrire, l'équivalent Java de touchest

try {
   //create a file named "testfile.txt" in the current working directory
   File myFile = new File("testfile.txt");
   if ( myFile.createNewFile() ) {
      System.out.println("Success!");
   } else {
      System.out.println("Failure!");
   }
} catch ( IOException ioe ) { ioe.printStackTrace(); }

createNewFile()vérifie l'existence et crée un fichier de manière atomique. Cela peut être utile si vous voulez vous assurer que vous avez été le créateur du fichier avant d'y écrire, par exemple.

Mark Peters
la source
1
[touch] met également à jour l'horodatage du fichier comme effet secondaire (s'il existe déjà). Cela a-t-il également cet effet secondaire?
Ape-inago
@ Ape-inago: Sur mon système, ce n'est certainement pas le cas (il renvoie simplement false et n'a aucun effet sur le fichier). Je ne voulais pas touchdans le sens général mais plutôt dans son usage secondaire courant pour créer un fichier sans y écrire de données. L'objectif documenté de touch est de mettre à jour l'horodatage du fichier. La création du fichier s'il n'existe pas est vraiment l'effet secondaire et peut être désactivée avec un interrupteur.
Mark Peters
Pour une raison telle que quoi? Ces exists()/createNewFile()séquences sont littéralement une perte de temps et d'espace.
Marquis de Lorne
12

Voici quelques-unes des façons possibles de créer et d'écrire un fichier en Java:

Utilisation de FileOutputStream

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
  bw.write("Write somthing to the file ...");
  bw.newLine();
  bw.close();
} catch (FileNotFoundException e){
  // File was not found
  e.printStackTrace();
} catch (IOException e) {
  // Problem when writing to the file
  e.printStackTrace();
}

Utilisation de FileWriter

try {
  FileWriter fw = new FileWriter("myOutFile.txt");
  fw.write("Example of content");
  fw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Utilisation de PrintWriter

try {
  PrintWriter pw = new PrintWriter("myOutFile.txt");
  pw.write("Example of content");
  pw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Utilisation de OutputStreamWriter

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  osw.write("Soe content ...");
  osw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Pour plus d'informations, consultez ce didacticiel sur la lecture et l'écriture de fichiers en Java .

Mehdi
la source
Je me demandais juste ... le FileWriterou ne devrait-il pas OutputStreamWriterêtre fermé dans un bloc enfin?
Wolfgang Schreurs
@WolfgangSchreurs, Oui, c'est encore mieux, je dois déplacer la déclaration de variable en dehors du bloc try pour pouvoir le faire.
Mehdi
Je viens de comprendre que l'utilisation de la fermeture automatique si elle est encore plus propre, pas besoin de déclarer une variable en dehors du bloc et les ressources seront fermées automatiquement même si une exception se produit (il faut ajouter explicitement un bloc finally). Voir: docs.oracle.com/javase/tutorial/essential/exceptions/…
Wolfgang Schreurs
J'ajouterais l'essai avec des ressources comme exemple séparé (pour séparer les différentes possibilités). Vous savez que SOF est un site Web collaboratif, allez-y et modifiez la réponse si vous le souhaitez.
Mehdi
10

Utilisation:

JFileChooser c = new JFileChooser();
c.showOpenDialog(c);
File writeFile = c.getSelectedFile();
String content = "Input the data here to be written to your file";

try {
    FileWriter fw = new FileWriter(writeFile);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.append(content);
    bw.append("hiiiii");
    bw.close();
    fw.close();
}
catch (Exception exc) {
   System.out.println(exc);
}
Rohit ZP
la source
c'est le moyen le plus simple que j'ai trouvé ... tous les problèmes sont résolus ici et seul le texte doit être inséré
Rohit ZP
10

la meilleure façon est d'utiliser Java7: Java 7 introduit une nouvelle façon de travailler avec le système de fichiers, ainsi qu'une nouvelle classe d'utilitaires - Files. En utilisant la classe Files, nous pouvons également créer, déplacer, copier, supprimer des fichiers et des répertoires; il peut également être utilisé pour lire et écrire dans un fichier.

public void saveDataInFile(String data) throws IOException {
    Path path = Paths.get(fileName);
    byte[] strToBytes = data.getBytes();

    Files.write(path, strToBytes);
}

Écrire avec FileChannel Si vous traitez de gros fichiers, FileChannel peut être plus rapide que les E / S standard. Le code suivant écrit String dans un fichier à l'aide de FileChannel:

public void saveDataInFile(String data) 
  throws IOException {
    RandomAccessFile stream = new RandomAccessFile(fileName, "rw");
    FileChannel channel = stream.getChannel();
    byte[] strBytes = data.getBytes();
    ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
    buffer.put(strBytes);
    buffer.flip();
    channel.write(buffer);
    stream.close();
    channel.close();
}

Écrire avec DataOutputStream

public void saveDataInFile(String data) throws IOException {
    FileOutputStream fos = new FileOutputStream(fileName);
    DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos));
    outStream.writeUTF(data);
    outStream.close();
}

Écrire avec FileOutputStream

Voyons maintenant comment utiliser FileOutputStream pour écrire des données binaires dans un fichier. Le code suivant convertit une chaîne en octets int et écrit les octets dans un fichier à l'aide d'un FileOutputStream:

public void saveDataInFile(String data) throws IOException {
    FileOutputStream outputStream = new FileOutputStream(fileName);
    byte[] strToBytes = data.getBytes();
    outputStream.write(strToBytes);

    outputStream.close();
}

Écrivez avec PrintWriter, nous pouvons utiliser un PrintWriter pour écrire du texte formaté dans un fichier:

public void saveDataInFile() throws IOException {
    FileWriter fileWriter = new FileWriter(fileName);
    PrintWriter printWriter = new PrintWriter(fileWriter);
    printWriter.print("Some String");
    printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000);
    printWriter.close();
}

Écrire avec BufferedWriter: utilisez BufferedWriter pour écrire une chaîne dans un nouveau fichier:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
    writer.write(data);

    writer.close();
}

ajoutez une chaîne au fichier existant:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
    writer.append(' ');
    writer.append(data);

    writer.close();
}
sajad abbasi
la source
9

Je pense que c'est le chemin le plus court:

FileWriter fr = new FileWriter("your_file_name.txt"); // After '.' write
// your file extention (".txt" in this case)
fr.write("Things you want to write into the file"); // Warning: this will REPLACE your old file content!
fr.close();
ben
la source
8

Pour créer un fichier sans écraser le fichier existant:

System.out.println("Choose folder to create file");
JFileChooser c = new JFileChooser();
c.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
c.showOpenDialog(c);
c.getSelectedFile();
f = c.getSelectedFile(); // File f - global variable
String newfile = f + "\\hi.doc";//.txt or .doc or .html
File file = new File(newfile);

try {
    //System.out.println(f);
    boolean flag = file.createNewFile();

    if(flag == true) {
        JOptionPane.showMessageDialog(rootPane, "File created successfully");
    }
    else {
        JOptionPane.showMessageDialog(rootPane, "File already exists");
    }
    /* Or use exists() function as follows:
        if(file.exists() == true) {
            JOptionPane.showMessageDialog(rootPane, "File already exists");
        }
        else {
            JOptionPane.showMessageDialog(rootPane, "File created successfully");
        }
    */
}
catch(Exception e) {
    // Any exception handling method of your choice
}
aashima
la source
7
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String [] args) {
        FileWriter fw= null;
        File file =null;
        try {
            file=new File("WriteFile.txt");
            if(!file.exists()) {
                file.createNewFile();
            }
            fw = new FileWriter(file);
            fw.write("This is an string written to a file");
            fw.flush();
            fw.close();
            System.out.println("File written Succesfully");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
Anurag Goel
la source
Ces exists()/createNewFile()séquences sont littéralement une perte de temps et d'espace.
Marquis de Lorne
6
package fileoperations;
import java.io.File;
import java.io.IOException;

public class SimpleFile {
    public static void main(String[] args) throws IOException {
        File file =new File("text.txt");
        file.createNewFile();
        System.out.println("File is created");
        FileWriter writer = new FileWriter(file);

        // Writes the content to the file
        writer.write("Enter the text that you want to write"); 
        writer.flush();
        writer.close();
        System.out.println("Data is entered into file");
    }
}
Suthan Srinivasan
la source
Ces exists()/createNewFile()séquences sont littéralement une perte de temps et d'espace.
Marquis de Lorne
5

Une seule ligne! pathet linesont des cordes

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

Files.write(Paths.get(path), lines.getBytes());
Ran Adler
la source
Ahem, l'auteur a explicitement spécifié les fichiers "texte". Et les fichiers texte sont composés de caractères. Les fichiers binaires sont composés d'octets. Hormis cela, on ne sait pas ce qui est lines. Si c'est un java.lang.String, alors l'appel getBytes()produira des octets en utilisant le codage par défaut de la plateforme , ce qui n'est pas très bon dans le cas général.
afk5min
5

La façon la plus simple que je puisse trouver:

Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
    writer.write("Hello, world!");
}

Cela ne fonctionnera probablement que pour 1.7+.

qed
la source
5

Cela vaut la peine d'essayer pour Java 7+:

 Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());

Cela semble prometteur ...

Olu Smith
la source
4

Si nous utilisons Java 7 et supérieur et connaissons également le contenu à ajouter (ajouté) au fichier, nous pouvons utiliser la méthode newBufferedWriter dans le package NIO.

public static void main(String[] args) {
    Path FILE_PATH = Paths.get("C:/temp", "temp.txt");
    String text = "\n Welcome to Java 8";

    //Writing to the file temp.txt
    try (BufferedWriter writer = Files.newBufferedWriter(FILE_PATH, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        writer.write(text);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Il y a quelques points à noter:

  1. C'est toujours une bonne habitude de spécifier le codage du jeu de caractères et pour cela nous avons une constante en classe StandardCharsets.
  2. Le code utilise une try-with-resourceinstruction dans laquelle les ressources sont automatiquement fermées après l'essai.

Bien que OP ne l'ait pas demandé, mais juste au cas où nous souhaiterions rechercher des lignes ayant un mot clé spécifique, par exemple, confidentialnous pouvons utiliser des API de flux en Java:

//Reading from the file the first line which contains word "confidential"
try {
    Stream<String> lines = Files.lines(FILE_PATH);
    Optional<String> containsJava = lines.filter(l->l.contains("confidential")).findFirst();
    if(containsJava.isPresent()){
        System.out.println(containsJava.get());
    }
} catch (IOException e) {
    e.printStackTrace();
}
akhil_mittal
la source
4

Lecture et écriture de fichiers en utilisant le flux d'entrée et de sortie:

//Coded By Anurag Goel
//Reading And Writing Files
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


public class WriteAFile {
    public static void main(String args[]) {
        try {
            byte array [] = {'1','a','2','b','5'};
            OutputStream os = new FileOutputStream("test.txt");
            for(int x=0; x < array.length ; x++) {
                os.write( array[x] ); // Writes the bytes
            }
            os.close();

            InputStream is = new FileInputStream("test.txt");
            int size = is.available();

            for(int i=0; i< size; i++) {
                System.out.print((char)is.read() + " ");
            }
            is.close();
        } catch(IOException e) {
            System.out.print("Exception");
        }
    }
}
Anurag Goel
la source
4

Incluez simplement ce package:

java.nio.file

Et puis vous pouvez utiliser ce code pour écrire le fichier:

Path file = ...;
byte[] buf = ...;
Files.write(file, buf);
Peter Mortensen
la source
4

En Java 8, utilisez Fichiers et chemins et utilisez la construction try-with-resources.

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class WriteFile{
    public static void main(String[] args) throws IOException {
        String file = "text.txt";
        System.out.println("Writing to file: " + file);
        // Files.newBufferedWriter() uses UTF-8 encoding by default
        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(file))) {
            writer.write("Java\n");
            writer.write("Python\n");
            writer.write("Clojure\n");
            writer.write("Scala\n");
            writer.write("JavaScript\n");
        } // the file will be automatically closed
    }
}
praveenraj4ever
la source
3

Il existe des moyens simples, comme:

File file = new File("filename.txt");
PrintWriter pw = new PrintWriter(file);

pw.write("The world I'm coming");
pw.close();

String write = "Hello World!";

FileWriter fw = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(fw);

fw.write(write);

fw.close();
imvp
la source
bwn'est pas utilisé.
Marquis de Lorne
Et le point d'écraser le fichier avec un nouveau contenu n'est pas indiqué.
Marquis de Lorne
3

Vous pouvez même créer un fichier temporaire à l'aide d'une propriété système , qui sera indépendante du système d'exploitation que vous utilisez.

File file = new File(System.*getProperty*("java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");
Muhammed Sayeed
la source
2

En utilisant la bibliothèque Google Guava, nous pouvons créer et écrire dans un fichier très facilement.

package com.zetcode.writetofileex;

import com.google.common.io.Files;
import java.io.File;
import java.io.IOException;

public class WriteToFileEx {

    public static void main(String[] args) throws IOException {

        String fileName = "fruits.txt";
        File file = new File(fileName);

        String content = "banana, orange, lemon, apple, plum";

        Files.write(content.getBytes(), file);
    }
}

L'exemple crée un nouveau fruits.txtfichier dans le répertoire racine du projet.

Jan Bodnar
la source
2

Lecture de la collection avec les clients et enregistrement dans un fichier, avec JFilechooser.

private void writeFile(){

    JFileChooser fileChooser = new JFileChooser(this.PATH);
    int retValue = fileChooser.showDialog(this, "Save File");

    if (retValue == JFileChooser.APPROVE_OPTION){

        try (Writer fileWrite = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileChooser.getSelectedFile())))){

            this.customers.forEach((c) ->{
                try{
                    fileWrite.append(c.toString()).append("\n");
                }
                catch (IOException ex){
                    ex.printStackTrace();
                }
            });
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}
hasskell
la source
2

Il existe au moins plusieurs façons de créer un fichier et d'y écrire:

Petits fichiers (1.7)

Vous pouvez utiliser l'une des méthodes d'écriture pour écrire des octets ou des lignes dans un fichier.

Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".;
Files.write(file, buf);

Ces méthodes prennent en charge la plupart du travail pour vous, telles que l'ouverture et la fermeture du flux, mais ne sont pas destinées à gérer des fichiers volumineux.

Écriture d'un fichier plus volumineux à l'aide d'E / S de flux mis en mémoire tampon (1.7)

Le java.nio.filepackage prend en charge les E / S de canal, qui déplacent les données dans des tampons, contournant certaines des couches qui peuvent goulot d'étranglement des E / S de flux.

String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
    writer.write(s, 0, s.length());
}

Cette approche est préférentielle en raison de ses performances efficaces, en particulier lors de l'achèvement d'un grand nombre d'opérations d'écriture. Les opérations tamponnées ont cet effet car elles ne sont pas obligées d'appeler la méthode d'écriture du système d'exploitation pour chaque octet, ce qui réduit les opérations d'E / S coûteuses.

Utilisation de l'API NIO pour copier (et en créer un nouveau) un fichier avec un flux de sortie (1.7)

Path oldFile = Paths.get("existing-file-path");
Path newFile = Paths.get("new-file-path");
try (OutputStream os = new FileOutputStream(newFile.toFile())) {
    Files.copy(oldFile, os);
}

Il existe également des méthodes supplémentaires qui permettent de copier tous les octets d'un flux d'entrée dans un fichier.

FileWriter (texte) (<1.7)

Écrit directement dans le fichier (moins de performances) et ne doit être utilisé que lorsque le nombre d'écritures est inférieur. Utilisé pour écrire des données orientées caractères dans un fichier.

String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();

FileOutputStream (binaire) (<1.7)

FileOutputStream est destiné à l'écriture de flux d'octets bruts tels que des données d'image.

byte data[] = "binary-to-write-to-file".getBytes();
FileOutputStream out = new FileOutputStream("file-name");
out.write(data);
out.close();

Avec cette approche, il faut envisager de toujours écrire un tableau d'octets plutôt que d'écrire un octet à la fois. L'accélération peut être assez importante - jusqu'à 10 fois plus ou plus. Par conséquent, il est recommandé d'utiliser les write(byte[])méthodes autant que possible.

Piotr Niewinski
la source