Come faccio a creare un file e scriverlo in Java?

Qual è il modo più semplice per creare e scrivere su un file (di testo) in Java?

Si noti che ciascuno dei seguenti esempi di codice può essere lanciato IOException. I blocchi try / catch / finally sono stati omessi per brevità. Vedi questo tutorial per informazioni sulla gestione delle eccezioni.

Si noti che ciascuno dei seguenti esempi di codice sovrascriverà il file se esiste già

Creazione di un file di testo:

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

Creazione di un file binario:

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

Gli utenti Java 7+ possono usare la Filesclasse per scrivere su file:

Creazione di un file di testo:

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

Creazione di un file binario:

byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);

In Java 7 e versioni successive:

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

Ci sono utilità utili per questo però:

• FileUtils.writeStringtoFile (..) da commons-io
• Files.write (..) da guava

Si noti inoltre che è possibile utilizzare aFileWriter , ma usa la codifica predefinita, che è spesso una cattiva idea - è meglio specificare la codifica in modo esplicito.

Di seguito è la risposta originale, precedente a 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*/}
}

Vedi anche: Lettura, scrittura e creazione di file (include NIO2).

Se hai già il contenuto che vuoi scrivere nel file (e non generato al volo), l' java.nio.file.Filesaggiunta in Java 7 come parte dell'I / O nativo fornisce il modo più semplice ed efficiente per raggiungere i tuoi obiettivi.

Fondamentalmente la creazione e la scrittura in un file è solo una linea, inoltre una semplice chiamata di metodo !

L'esempio seguente crea e scrive in 6 file diversi per mostrare come può essere utilizzato:

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

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

Ecco un piccolo programma di esempio per creare o sovrascrivere un file. È la versione lunga, quindi può essere compresa più facilmente.

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

Un modo molto semplice per creare e scrivere su un file in 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);
        }
    }
}

Uso:

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'utilizzo try()chiuderà automaticamente il flusso. Questa versione è breve, veloce (con buffer) e consente di scegliere la codifica.

Questa funzione è stata introdotta in Java 7.

Qui stiamo inserendo una stringa in un file di testo:

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

Possiamo facilmente creare un nuovo file e aggiungere contenuto al suo interno.

Poiché l'autore non ha specificato se richiedono una soluzione per le versioni Java che sono state EoL'd (sia da Sun che da IBM, e queste sono tecnicamente le JVM più diffuse) e dal fatto che la maggior parte delle persone sembra aver risposto al domanda dell'autore prima che fosse specificato che si tratta di un file di testo (non binario) , ho deciso di fornire la mia risposta.

Prima di tutto, Java 6 ha generalmente raggiunto la fine della sua vita, e poiché l'autore non ha specificato che ha bisogno di compatibilità legacy, immagino significhi automaticamente Java 7 o versioni successive (Java 7 non è ancora EoL fatto da IBM). Quindi, possiamo dare un'occhiata al tutorial I / O sui file: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Prima della versione Java SE 7, la classe java.io.File era il meccanismo utilizzato per l'I / O dei file, ma presentava numerosi inconvenienti.

• Molti metodi non generavano eccezioni quando fallivano, quindi era impossibile ottenere un utile messaggio di errore. Ad esempio, se la cancellazione di un file non è riuscita, il programma riceverà un "errore di eliminazione" ma non saprebbe se era perché il file non esisteva, l'utente non aveva le autorizzazioni o c'era qualche altro problema.
• Il metodo di rinomina non ha funzionato in modo coerente su tutte le piattaforme.
• Non c'era un vero supporto per i collegamenti simbolici.
• È stato richiesto un maggiore supporto per i metadati, come autorizzazioni per i file, proprietario del file e altri attributi di sicurezza. L'accesso ai metadati dei file era inefficiente.
• Molti dei metodi File non sono stati ridimensionati. La richiesta di un elenco di directory di grandi dimensioni su un server potrebbe provocare un blocco. Le directory di grandi dimensioni potrebbero anche causare problemi di risorse di memoria, con conseguente negazione del servizio.
• Non è stato possibile scrivere un codice affidabile che potesse ricorrere in modo ricorsivo a un albero di file e rispondere in modo appropriato in presenza di collegamenti simbolici circolari.

Oh bene, questo esclude java.io.File. Se un file non può essere scritto / aggiunto, potresti non essere nemmeno in grado di sapere il perché.

Possiamo continuare a guardare il tutorial: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Se hai tutte le righe che dovresti scrivere (aggiungere) al file di testo in anticipo , l'approccio consigliato è 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 ...-

Ecco un esempio (semplificato):

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

Un altro esempio (append):

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

Se vuoi scrivere il contenuto del file mentre vai : 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 ...-

Esempio semplificato (Java 8 o versioni successive):

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

Un altro esempio (append):

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

Questi metodi richiedono uno sforzo minimo da parte dell'autore e dovrebbero essere preferiti a tutti gli altri quando si scrivono su file [di testo].

Se desideri avere un'esperienza relativamente indolore, puoi anche dare un'occhiata al pacchetto IO di Apache Commons , più specificamente alla FileUtilsclasse .

Non dimenticare di controllare le librerie di terze parti. Joda-Time per la manipolazione della data, Apache Commons LangStringUtils per le operazioni di stringa comuni e simili possono rendere il tuo codice più leggibile.

Java è un ottimo linguaggio, ma la libreria standard a volte è un po 'di basso livello. Potente, ma di basso livello.

Se per qualche motivo vuoi separare l'atto di creare e scrivere, l'equivalente Java di touchè

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()esegue un controllo di esistenza e il file viene creato atomicamente. Questo può essere utile se vuoi assicurarti di essere il creatore del file prima di scriverlo, per esempio.

Ecco alcuni dei modi possibili per creare e scrivere un file in Java:

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

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

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

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

Per ulteriori controlli, consultare questo tutorial su Come leggere e scrivere file in Java .

Uso:

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

il modo migliore è usare Java7: Java 7 introduce un nuovo modo di lavorare con il filesystem, insieme a una nuova classe di utilità - File. Utilizzando la classe Files, possiamo creare, spostare, copiare, eliminare anche file e directory; può anche essere usato per leggere e scrivere su un file.

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

    Files.write(path, strToBytes);
}

Scrivi con FileChannel Se hai a che fare con file di grandi dimensioni, FileChannel può essere più veloce di IO standard. Il codice seguente scrive String in un file utilizzando 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();
}

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

Scrivi con FileOutputStream

Vediamo ora come possiamo utilizzare FileOutputStream per scrivere dati binari in un file. Il codice seguente converte un byte int String e scrive i byte su file usando un FileOutputStream:

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

    outputStream.close();
}

Scrivi con PrintWriter possiamo usare un PrintWriter per scrivere un testo formattato in un file:

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

Scrivi con BufferedWriter: usa BufferedWriter per scrivere una stringa in un nuovo file:

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

    writer.close();
}

aggiungere una stringa al file esistente:

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

    writer.close();
}

Penso che questo sia il modo più breve:

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

Per creare un file senza sovrascrivere il file esistente:

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
}

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

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

Solo una riga! pathe linesono stringhe

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

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

Il modo più semplice che posso trovare:

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

Probabilmente funzionerà solo per 1.7+.

Vale la pena provare per Java 7+:

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

Sembra promettente ...

Se stiamo utilizzando Java 7 e versioni successive e conosciamo anche il contenuto da aggiungere (aggiunto) al file, possiamo utilizzare il metodo newBufferedWriter nel pacchetto 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();
    }
}

Ci sono alcuni punti da notare:

1. È sempre una buona abitudine specificare la codifica del set di caratteri e per questo abbiamo una costante in classe StandardCharsets.
2. Il codice utilizza try-with-resourceun'istruzione in cui le risorse vengono automaticamente chiuse dopo il tentativo.

Sebbene OP non l'abbia chiesto, ma nel caso in cui desideriamo cercare righe con una parola chiave specifica, ad esempio confidentialpossiamo utilizzare API di flusso in 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();
}

Lettura e scrittura dei file mediante input e 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");
        }
    }
}

Includi solo questo pacchetto:

java.nio.file

E quindi puoi usare questo codice per scrivere il file:

Path file = ...;
byte[] buf = ...;
Files.write(file, buf);

In Java 8 usa File e Percorsi e usa il costrutto 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
    }
}

Ci sono alcuni modi semplici, come:

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

È anche possibile creare un file temporaneo utilizzando una proprietà di sistema , che sarà indipendente dal sistema operativo in uso.

File file = new File(System.*getProperty*("java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");

Utilizzando la libreria Guava di Google, possiamo creare e scrivere su un file molto facilmente.

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'esempio crea un nuovo fruits.txtfile nella directory principale del progetto.

Leggere la raccolta con i clienti e salvare su file, con 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();
        }
    }
}

Esistono almeno diversi modi per creare un file e scriverlo:

Piccoli file (1.7)

È possibile utilizzare uno dei metodi di scrittura per scrivere byte o righe in un file.

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

Questi metodi si occupano della maggior parte del lavoro per te, come l'apertura e la chiusura del flusso, ma non sono destinati alla gestione di file di grandi dimensioni.

Scrittura di file di dimensioni maggiori utilizzando Buffered Stream I / O (1.7)

Il java.nio.filepacchetto supporta l'I / O del canale, che sposta i dati nei buffer, bypassando alcuni dei livelli che possono bloccare l'I / O del flusso di bottiglia.

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

Questo approccio è preferenziale a causa delle sue prestazioni efficienti soprattutto quando si completano numerose operazioni di scrittura. Le operazioni con buffer hanno questo effetto in quanto non sono richieste per chiamare il metodo di scrittura del sistema operativo per ogni singolo byte, riducendo le costose operazioni di I / O.

Utilizzo dell'API NIO per copiare (e crearne uno nuovo) un file con un Outputstream (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);
}

Esistono anche metodi aggiuntivi che consentono di copiare tutti i byte da un flusso di input a un file.

FileWriter (testo) (<1.7)

Scrive direttamente nel file (meno prestazioni) e dovrebbe essere usato solo quando il numero di scritture è inferiore. Utilizzato per scrivere dati orientati ai caratteri in un file.

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

FileOutputStream (binario) (<1.7)

FileOutputStream è pensato per scrivere flussi di byte grezzi come i dati di immagine.

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

Con questo approccio si dovrebbe considerare di scrivere sempre un array di byte anziché scrivere un byte alla volta. L'accelerazione può essere piuttosto significativa - fino a 10 volte superiore o superiore. Pertanto si consiglia di utilizzare i write(byte[])metodi ogni volta che è possibile.