¿Cómo creo un archivo y le escribo en Java?

¿Cuál es la forma más sencilla de crear y escribir en un archivo (de texto) en Java?

Tenga en cuenta que cada uno de los ejemplos de código a continuación puede arrojar IOException. Los bloques Try / catch / finally se han omitido por brevedad. Consulte este tutorial para obtener información sobre el manejo de excepciones.

Tenga en cuenta que cada uno de los ejemplos de código a continuación sobrescribirá el archivo si ya existe

Crear un archivo de texto:

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

Crear un archivo binario:

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

Los usuarios de Java 7+ pueden usar la Filesclase para escribir en archivos:

Crear un archivo de texto:

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

Crear un archivo binario:

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

En Java 7 y superior:

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

Sin embargo, hay utilidades útiles para eso:

• FileUtils.writeStringtoFile (..) de commons-io
• Files.write (..) de guayaba

Tenga en cuenta también que puede usar a FileWriter, pero usa la codificación predeterminada, que a menudo es una mala idea; es mejor especificar la codificación explícitamente.

A continuación se muestra la respuesta original anterior 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*/}
}

Consulte también: Lectura, escritura y creación de archivos (incluye NIO2).

Si ya tiene el contenido que desea escribir en el archivo (y no se genera sobre la marcha), la java.nio.file.Filesadición en Java 7 como parte de la E / S nativa proporciona la forma más simple y eficiente de lograr sus objetivos.

Básicamente, crear y escribir en un archivo es solo una línea, ¡además una simple llamada al método !

El siguiente ejemplo crea y escribe en 6 archivos diferentes para mostrar cómo se puede usar:

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

Aquí hay un pequeño programa de ejemplo para crear o sobrescribir un archivo. Es la versión larga, por lo que se puede entender más fácilmente.

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

Una forma muy sencilla de crear y escribir en un archivo 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);
        }
    }
}

Utilizar:

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

El uso try()cerrará la transmisión automáticamente. Esta versión es corta, rápida (almacenada) y permite elegir la codificación.

Esta característica se introdujo en Java 7.

Aquí estamos ingresando una cadena en un archivo de texto:

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

Podemos crear fácilmente un nuevo archivo y agregarle contenido.

Dado que el autor no especificó si requieren una solución para las versiones de Java que han sido EoL'd (tanto por Sun como por IBM, y estas son técnicamente las JVM más extendidas), y debido al hecho de que la mayoría de las personas parecen haber respondido pregunta del autor antes de que se especificara que es un archivo de texto (no binario) , he decidido proporcionar mi respuesta.

En primer lugar, Java 6 generalmente ha llegado al final de su vida útil, y dado que el autor no especificó que necesita compatibilidad heredada, supongo que automáticamente significa Java 7 o superior (Java 7 aún no es EoL'd por IBM). Entonces, podemos mirar directamente el tutorial de E / S de archivo: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Antes del lanzamiento de Java SE 7, la clase java.io.File era el mecanismo utilizado para la E / S de archivos, pero tenía varios inconvenientes.

• Muchos métodos no arrojaron excepciones cuando fallaron, por lo que fue imposible obtener un mensaje de error útil. Por ejemplo, si fallara la eliminación de un archivo, el programa recibiría un "error de eliminación" pero no sabría si fue porque el archivo no existía, el usuario no tenía permisos o si había algún otro problema.
• El método de cambio de nombre no funcionó de manera consistente en todas las plataformas.
• No hubo apoyo real para enlaces simbólicos.
• Se deseaba más compatibilidad con metadatos, como permisos de archivos, propietario de archivos y otros atributos de seguridad. El acceso a los metadatos del archivo fue ineficiente.
• Muchos de los métodos de archivo no escalaron. Solicitar una lista de directorio grande a través de un servidor podría provocar un bloqueo. Los directorios grandes también pueden causar problemas de recursos de memoria, lo que resulta en una denegación de servicio.
• No era posible escribir código confiable que pudiera recorrer recursivamente un árbol de archivos y responder de manera apropiada si hubiera enlaces simbólicos circulares.

Oh, bueno, eso descarta java.io.File. Si no se puede escribir / agregar un archivo, es posible que ni siquiera pueda saber por qué.

Podemos seguir mirando el tutorial: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Si tiene todas las líneas que escribirá (agregará) al archivo de texto de antemano , el enfoque recomendado es 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 ...-

Aquí hay un ejemplo (simplificado):

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

Otro ejemplo (agregar):

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

Si desea escribir el contenido del archivo a medida que avanza : 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 ...-

Ejemplo simplificado (Java 8 o superior):

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

Otro ejemplo (agregar):

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

Estos métodos requieren un esfuerzo mínimo por parte del autor y deben preferirse a todos los demás al escribir en archivos [text].

Si desea tener una experiencia relativamente libre de dolor, también puede echar un vistazo al paquete IO de Apache Commons , más específicamente a la FileUtilsclase .

Nunca olvides consultar las bibliotecas de terceros. Joda-Time para la manipulación de la fecha, Apache Commons LangStringUtils para las operaciones de cadena comunes y demás pueden hacer que su código sea más legible.

Java es un gran lenguaje, pero la biblioteca estándar a veces es un poco de bajo nivel. Potente, pero de bajo nivel, no obstante.

Si por alguna razón desea separar el acto de crear y escribir, el equivalente de Java touches

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()hace una comprobación de existencia y crea un archivo atómicamente. Esto puede ser útil si desea asegurarse de que fue el creador del archivo antes de escribir en él, por ejemplo.

Estas son algunas de las formas posibles de crear y escribir un archivo en Java:

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

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

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

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

Para obtener más información, consulte este tutorial sobre Cómo leer y escribir archivos en Java .

Utilizar:

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

la mejor manera es usar Java7: Java 7 presenta una nueva forma de trabajar con el sistema de archivos, junto con una nueva clase de utilidad: Archivos. Usando la clase Archivos, también podemos crear, mover, copiar, eliminar archivos y directorios; También se puede utilizar para leer y escribir en un archivo.

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

    Files.write(path, strToBytes);
}

Escribir con FileChannel Si se trata de archivos grandes, FileChannel puede ser más rápido que el estándar IO. El siguiente código escribe String en un archivo usando 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();
}

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

Escribir con FileOutputStream

Veamos ahora cómo podemos usar FileOutputStream para escribir datos binarios en un archivo. El siguiente código convierte un String int bytes y escribe los bytes en un archivo usando un FileOutputStream:

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

    outputStream.close();
}

Escriba con PrintWriter podemos usar un PrintWriter para escribir texto formateado en un archivo:

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

Escriba con BufferedWriter: use BufferedWriter para escribir una Cadena en un nuevo archivo:

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

    writer.close();
}

agregue una cadena al archivo existente:

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

    writer.close();
}

Creo que este es el camino más corto:

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

Para crear un archivo sin sobrescribir el archivo existente:

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

¡Una sola línea! pathy lineson cadenas

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

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

La forma más simple que puedo encontrar:

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

Probablemente solo funcionará para 1.7+.

Vale la pena probarlo para Java 7+:

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

Parece prometedor ...

Si estamos utilizando Java 7 y superior y también sabemos el contenido que se agregará (adjuntará) al archivo, podemos utilizar el método newBufferedWriter en el paquete 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();
    }
}

Hay algunos puntos a tener en cuenta:

1. Siempre es un buen hábito especificar la codificación de juego de caracteres y para eso tenemos constantes en la clase StandardCharsets.
2. El código usa una try-with-resourcedeclaración en la que los recursos se cierran automáticamente después del intento.

Aunque OP no ha pedido, pero solo en caso de que queramos buscar líneas que tengan alguna palabra clave específica, por ejemplo confidential, podemos hacer uso de las API de transmisión 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();
}

Lectura y escritura de archivos usando el flujo de entrada y salida:

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

Solo incluye este paquete:

java.nio.file

Y luego puede usar este código para escribir el archivo:

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

En Java 8, use Archivos y rutas y use la construcción 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
    }
}

Hay algunas formas simples, como:

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

Incluso puede crear un archivo temporal utilizando una propiedad del sistema , que será independiente del sistema operativo que esté utilizando.

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

Usando la biblioteca de guayaba de Google, podemos crear y escribir en un archivo muy fácilmente.

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

El ejemplo crea un nuevo fruits.txtarchivo en el directorio raíz del proyecto.

Leer la colección con los clientes y guardarla en un archivo, 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();
        }
    }
}

Hay al menos varias formas de crear un archivo y escribir en él:

Pequeños archivos (1.7)

Puede usar uno de los métodos de escritura para escribir bytes o líneas en un archivo.

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

Estos métodos se encargan de la mayor parte del trabajo, como abrir y cerrar la transmisión, pero no están destinados a manejar archivos grandes.

Escritura de archivos más grandes utilizando E / S de flujo en búfer (1.7)

El java.nio.filepaquete admite E / S de canal, que mueve datos en búferes, sin pasar por algunas de las capas que pueden obstaculizar la E / S de flujo.

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

Este enfoque es preferencial debido a su rendimiento eficiente, especialmente al completar una gran cantidad de operaciones de escritura. Las operaciones almacenadas tienen este efecto ya que no se requiere que llamen al método de escritura del sistema operativo para cada byte, lo que reduce las costosas operaciones de E / S.

Usando NIO API para copiar (y crear uno nuevo) un archivo 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);
}

También hay métodos adicionales que permiten copiar todos los bytes de una secuencia de entrada a un archivo.

FileWriter (texto) (<1.7)

Escribe directamente en el archivo (menos rendimiento) y debe usarse solo cuando el número de escrituras es menor. Se usa para escribir datos orientados a caracteres en un archivo.

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

FileOutputStream (binario) (<1.7)

FileOutputStream está diseñado para escribir secuencias de bytes sin formato, como datos de imágenes.

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

Con este enfoque, se debe considerar escribir siempre una matriz de bytes en lugar de escribir un byte a la vez. La aceleración puede ser bastante significativa: hasta 10 veces más o más. Por lo tanto, se recomienda utilizar los write(byte[])métodos siempre que sea posible.