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



Answers

En Java 7 et plus:

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

Il y a des utilités utiles pour cela:

Notez également que vous pouvez utiliser un 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.

Ci-dessous est la réponse originale, préalable à 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).

Question

Quel est le moyen le plus simple pour créer et écrire dans un fichier (texte) en Java?




Je pense que c'est le plus court chemin:

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



Le moyen le plus simple que je peux 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+.




Lecture et écriture de fichiers en utilisant input et outputstream:

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



Il y a 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();



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 de try() fermera le flux automatiquement. Cette version est courte, rapide (mise en mémoire tampon) et permet de choisir l'encodage.

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




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



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

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

Utiliser 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 tutoriel sur Comment lire et écrire des fichiers en Java .




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



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.




Vous pouvez même créer un fichier temporaire en utilisant 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");



Puisque l'auteur n'a pas précisé s'il exigeait une solution pour les versions de Java qui ont été EoL'd (par Sun et IBM, techniquement les plus répandues JVMs), et parce que la plupart des gens semblent avoir répondu à la question de l'auteur avant qu'il ne soit spécifié qu'il s'agit d'un fichier texte (non-binaire) , j'ai décidé de fournir 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 spécifié de compatibilité héritée, j'imagine que cela signifie automatiquement Java 7 ou supérieur (Java 7 n'est pas encore édité par IBM). Ainsi, nous pouvons regarder directement le tutoriel d'E / S de fichier: 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 jetaient pas d'exceptions lorsqu'elles échouaient, 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 permissions, ou il y avait un autre problème.
  • La méthode de changement de nom n'a pas fonctionné de manière cohérente sur toutes les plates-formes.
  • Il n'y avait pas de réel soutien pour les liens symboliques.
  • Davantage de prise en charge des métadonnées était souhaitée, telles que les autorisations de fichier, le propriétaire du fichier et d'autres attributs de sécurité. L'accès aux métadonnées de fichiers était inefficace.
  • La plupart des méthodes File n'ont pas évolué. Demander une liste de répertoire volumineuse sur un serveur peut entraîner un blocage. Les grands répertoires 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 de manière récursive 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 pouvez 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 allez écrire (append) 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 (append):

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

Si vous voulez é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 (append):

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 devraient être préférées à toutes les autres lors de l'écriture dans des fichiers [texte].




Pour plusieurs fichiers, vous pouvez utiliser:

static void out(String[] name, String[] content) {

    File path = new File(System.getProperty("user.dir") + File.separator + "OUT");

    for (File file : path.listFiles())
        if (!file.isDirectory())
            file.delete();
    path.mkdirs();

    File c;

    for (int i = 0; i != name.length; i++) {
        c = new File(path + File.separator + name[i] + ".txt");
        try {
            c.createNewFile();
            FileWriter fiWi = new FileWriter(c.getAbsoluteFile());
            BufferedWriter buWi = new BufferedWriter(fiWi);
            buWi.write(content[i]);
            buWi.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Ça fonctionne très bien.




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
}



Links