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


1383

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

Respuestas:


1735

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

58
A tener en cuenta PrintStream truncará el tamaño del archivo a cero si el archivo ya existe
Covar

34
PrintWriter se puede usar (y a menudo se usa), pero no es (conceptualmente) la clase correcta para el trabajo. De los documentos: "PrintWriter prints formatted representations of objects to a text-output stream. "la respuesta de Bozho es más correcta, aunque parece engorrosa (siempre puedes envolverla en algún método de utilidad).
leonbloy

14
Entonces, ¿dónde se creará el archivo de texto después de que la aplicación se construya y se use en otra PC ya que no hemos dado la ruta?
Marlon Abeykoon

13
@MarlonAbeykoon Buena pregunta. La respuesta es que creará el archivo de texto en el directorio de trabajo . El directorio de trabajo es el directorio desde el que ejecuta su programa. Por ejemplo, si ejecuta su programa desde la línea de comandos, el directorio de trabajo será el directorio en el que se encuentre "en ese momento" (en Linux, escriba "pwd" para ver el directorio de trabajo actual). O, si hago doble clic en un archivo JAR en mi escritorio para ejecutarlo, entonces el directorio de trabajo será el escritorio.
Michael

8
writer.close()debería estar en un bloque finalmente
Thierry

416

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:

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


55
@leonbloy Sé que este es un comentario antiguo, pero si alguien lo ve, ¿le importaría explicar por qué no es "siempre beneficioso"? Al menos aquí dice "top eficiente" docs.oracle.com/javase/1.5.0/docs/api/java/io/…
Juan

14
Parece que el escritor no tiene un método writeln (). Solo tiene escritura ()
YankeeWhiskey

10
Si cambia el tipo de escritor a BufferedWriter (que en realidad es), puede usar writer.newLine ()
Niek

44
No parece correcto tener un try / catch dentro de un finalmente. Sé por qué, pero parece un olor a código.
cenizas999

44
@Trengot lo hace. Llamar close()a cualquier transmisión envuelta alrededor de cualquier otra cerrará también todas las transmisiones internas.
Financia la demanda de Mónica el

132

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

Bien hecho. Me gusta el ejemplo file5 y file6. Para probar el archivo 6, asegúrese de ejecutar el programa dos veces, luego verá que agrega las líneas nuevamente.
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();
          }
        }
    }
}

18
¿No sería mejor poner output.close () en un bloque finalmente?
qed

77
El mero código nunca puede constituir una respuesta aquí. Tienes que explicarlo.
Marqués de Lorne

77
en realidad esto no se compilará, output.close()lanza IOException
Bob Yoplait

43

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

39

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

77
El File.exists()/createNewFile()código aquí es inútil y derrochador. El sistema operativo ya tiene que hacer exactamente lo mismo cuando new FileWriter()se crea. Estás obligando a que todo suceda dos veces.
Marqués de Lorne

1
El File.exists () / createNewFile () no es inútil y derrochador. Estaba buscando una manera de ejecutar código diferente en función de si el archivo ya está presente o no. Esto fue muy útil.
KirstieBallance

2
Usé este método, pero debes saber que sobrescribe el archivo cada vez. Si desea que se agregue en caso de que exista el archivo, debe crear una instancia de la FileWritersiguiente manera:new FileWriter(file.getAbsoluteFile(),true)
Adelin

2
Es tanto inútil y un desperdicio, por la razón indiqué. Usted está causando dos pruebas de existencia, dos creaciones, y una deleción, y que está no ejecución de código diferente aquí en función de si o no el archivo ya está presente.
Marqués de Lorne

34

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.


55
Cabe señalar que esta es una característica de Java 7, por lo que no funcionará en versiones anteriores de Java.
Dan Temple

3
Se podría usar la StandardCharsets.UTF_8cadena "constante" en lugar de la cadena "utf-8" (Esto evita fallas tipográficas) ...new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8)...- java.nio.charset.StandardCharsetsse introduce en Java 7
Ralph

20

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.


Tenga en cuenta que cerrar BufferedWriter es suficiente ya que también se encarga de cerrar FileWriter.
rbaleksandar

17

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 no se puede escribir / agregar un archivo, es posible que ni siquiera sepas por qué' no es correcto. Sabrá exactamente por qué, a partir del texto del FileNotFoundExceptionque se lanza cuando falla la operación.
Marqués de Lorne

"Muchos métodos no arrojaron excepciones cuando fallaron, por lo que era imposible obtener un mensaje de error útil. Por ejemplo, si fallaba la eliminación de un archivo, el programa recibiría un" error de eliminación "pero no sabría si era porque el archivo no existía, el usuario no tenía permisos o había algún otro problema ".
afk5min

Lee lo que escribí. " Si no se puede escribir / agregar un archivo, es posible que ni siquiera pueda obtener un mensaje de error útil" es incorrecto, por la razón que dije, y lo sigue siendo. Estás cambiando de tema. Tu propio tema.
Marqués de Lorne

Examinaré las implementaciones integradas para los sistemas de archivos típicos (que estarían en OpenJDK, pero no tengo ninguna razón para pensar que esta parte sería diferente en el propietario Oracle JDK, o significativamente diferente en el propietario IBM JDK, entre otros) y actualizaré Mi respuesta basada en estos hallazgos. Su comentario tiene sentido, solo porque 'muchos métodos' pueden tener problemas, el autor claramente declaró que solo les interesa la operación de escribir / agregar al archivo.
afk5min

La razón es que ninguno de los métodos a los que está llamando no arroja las excepciones apropiadas que contienen mensajes de error apropiados. Si tiene un contraejemplo que respalde su afirmación, depende de usted proporcionarlo.
Marqués de Lorne

16

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.


1
El método más simple para escribir archivos FileUtilses static void write(File file, CharSequence data). Ejemplo de uso: import org.apache.commons.io.FileUtils; FileUtils.write(new File("example.txt"), "string with data");. FileUtilsTambién tiene writeLines, que toma una Collectionde las líneas.
Rory O'Kane

12

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.


1
[touch] también actualiza la marca de tiempo del archivo como efecto secundario (si ya existe). ¿Esto también tiene ese efecto secundario?
Ape-inago

@ Ape-inago: en mi sistema ciertamente no lo hizo (solo devuelve falso y no tiene ningún efecto en el archivo). No quise decir touchen el sentido general, sino más bien en su uso secundario común para crear un archivo sin escribir datos en él. El propósito documentado de touch es actualizar la marca de tiempo en el archivo. Crear el archivo si no existe es realmente el efecto secundario, y se puede deshabilitar con un interruptor.
Mark Peters

¿Por alguna razón como qué? Estas exists()/createNewFile()secuencias son literalmente una pérdida de tiempo y espacio.
Marqués de Lorne

12

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 .


Sólo me preguntaba ... ¿no debería FileWriterni OutputStreamWriterestar cerrado en un bloque finally?
Wolfgang Schreurs

@WolfgangSchreurs, Sí, es aún mejor, tengo que mover la declaración de variable fuera del bloque try para poder hacer eso.
Mehdi

Me acabo de dar cuenta de que hacer uso del cierre automático si es incluso más limpio, no es necesario declarar variables fuera del bloque y los recursos se cerrarán automáticamente incluso si se produce una excepción (es necesario agregar explícitamente un bloque finalmente). Ver: docs.oracle.com/javase/tutorial/essential/exceptions/…
Wolfgang Schreurs

Agregaría la prueba con recursos como un ejemplo separado (para separar diferentes posibilidades). Usted sabe que SOF es un sitio web colaborativo, continúe y modifique la respuesta si desea tener el derecho.
Mehdi

10

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

esta es la forma más fácil que encontré ... todos los problemas se resuelven aquí y solo se necesita insertar el texto
Rohit ZP

10

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

9

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

8

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
}

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

Estas exists()/createNewFile()secuencias son literalmente una pérdida de tiempo y espacio.
Marqués 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");
    }
}

Estas exists()/createNewFile()secuencias son literalmente una pérdida de tiempo y espacio.
Marqués de Lorne

5

¡Una sola línea! pathy lineson cadenas

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

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

Ejem, el autor especificó explícitamente archivos de "texto". Y los archivos de texto están compuestos de caracteres. Los archivos binarios están compuestos por bytes. Aparte de eso, no está claro qué es lines. Si es un java.lang.String, entonces la llamada getBytes()producirá bytes usando la codificación predeterminada de la plataforma , que no es muy buena en el caso general.
afk5min

5

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+.


5

Vale la pena probarlo para Java 7+:

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

Parece prometedor ...


4

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

4

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

4

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

4

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

3

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

bwEstá sin usar.
Marqués de Lorne

Y no se menciona el punto de sobrescribir el archivo con nuevo contenido.
Marqués de Lorne

3

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

2

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.


2

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

2

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.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.