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


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


1130
2018-05-21 19:58


origen


Respuestas:


Tenga en cuenta que cada una de las siguientes muestras de código puede arrojar IOException. Los bloques Try / catch / finally han sido omitidos por brevedad. Ver este tutorial para obtener información sobre el manejo de excepciones.

Crear un archivo de texto (tenga en cuenta que esto sobrescribirá el archivo si ya existe):

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 (esto también sobrescribirá el archivo):

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

Java 7+ los usuarios pueden usar el Files clase para escribir en los archivos:

Creando 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, Charset.forName("UTF-8"));
//Files.write(file, lines, Charset.forName("UTF-8"), StandardOpenOption.APPEND);

Creando un archivo binario

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

1454
2018-05-21 20:06



En Java 7 y versiones posteriores:

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

Sin embargo, hay utilidades útiles para eso:

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

A continuación se encuentra la respuesta original, previa 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*/}
}

Ver también: Leer, escribir y crear archivos (incluye NIO2).


355
2018-05-21 20:09



Si ya tiene el contenido que desea escribir en el archivo (y no se genera sobre la marcha), el java.nio.file.Files Además, en Java 7 como parte de las E / S nativas, proporciona la manera 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();
}

118
2018-04-22 14:01



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

69
2018-05-21 20:09



Aquí hay un pequeño ejemplo de programa 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();
    }
}

39
2018-04-09 18:05



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
}  

Utilizando try() Cerrará la transmisión automáticamente. Esta versión es corta, rápida (en búfer) y permite elegir la codificación.

Esta característica fue introducida en Java 7.


30
2018-04-19 14:35



Una forma muy simple 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);
        }
    }
}

Referencia: Archivo crear ejemplo en java


30
2017-11-19 16:07



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.


17
2018-06-10 11:55



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

Nunca olvides consultar las bibliotecas de terceros. Joda-Time para la manipulación de la fecha, Apache Commons Lang StringUtils para las operaciones de cadena comunes y eso puede 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.


15
2018-05-21 20:10



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


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

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

  • Muchos métodos no arrojaban excepciones cuando fallaban, así que era   imposible obtener un mensaje de error útil. Por ejemplo, si un archivo   la eliminación falló, el programa recibiría un "error de eliminación" pero   no sabría si fue porque el archivo no existía, el usuario no lo hizo   tiene permisos, o hubo algún otro problema.
  • El método de cambio de nombre   no funcionó de manera consistente en todas las plataformas.
  • No hubo un apoyo real   para enlaces simbólicos.
  • Se deseaba más soporte para los metadatos, como   permisos de archivos, propietario del archivo y otros atributos de seguridad. Accediendo   los metadatos del archivo fueron ineficientes.
  • Muchos de los métodos de archivo no se escalaron.   Solicitar una lista grande de directorios en un servidor podría resultar en una   colgar. Los directorios grandes también pueden causar problemas de recursos de memoria,   lo que resulta en una denegación de servicio.
  • No fue posible escribir   código confiable que podría recorrer recursivamente un árbol de archivos y responder   apropiadamente si hubiera enlaces simbólicos circulares.

Oh, bueno, eso descarta java.io.File. Si no se puede escribir / anexar un archivo, es probable que no sepas por qué.


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

Si tiene todas las líneas, deberá escribir (adjuntar) al archivo de texto con anticipación, 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 (adjuntar):

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

Si quieres escribir contenido de archivo a medida que avanzas: 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 (adjuntar):

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 mínimo esfuerzo por parte del autor y deben preferirse a todos los demás al escribir en archivos [de texto].


11
2018-05-13 04:39



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

9
2017-07-15 14:43