¿Cómo agregar una nueva línea de texto a un archivo existente en Java?

Question

Me gustaría agregar una nueva línea a un archivo existente sin borrar la información actual de ese archivo. En resumen, aquí es la metodología que estoy usando la hora actual:

import java.io.BufferedWriter; 
import java.io.FileWriter; 
import java.io.Writer; 

Writer output; 
output = new BufferedWriter(new FileWriter(my_file_name)); //clears file every time 
output.append("New Line!"); 
output.close(); 

El problema con las líneas anteriores es simplemente que están borrando todo el contenido de mi archivo existente a continuación, añadir el nuevo texto de la línea.

Quiero agregar texto al final del contenido de un archivo sin borrar o reemplazar nada.

Answer 1

tiene que abrir el archivo en modo de adición, que se puede lograr utilizando el constructor FileWriter(String fileName, boolean append).

output = new BufferedWriter(new FileWriter(my_file_name, true)); 

debe hacer el truco

Answer 2

En la línea 2 new FileWriter(my_file_name) cambio a new FileWriter(my_file_name, true) por lo que está añadiendo al archivo en lugar de sobrescribir.

Answer 3

Puede usar el constructor FileWriter(String fileName, boolean append) si desea agregar datos al archivo.

cambiar el código para esto:

output = new BufferedWriter(new FileWriter(my_file_name, true)); 

De FileWriter javadoc:

construye un objeto FileWriter dado un nombre de archivo . Si el segundo argumento es true, los bytes se escribirán en al final del archivo en lugar del que comienza.

Answer 4

La solución con FileWriter está trabajando, sin embargo, no tienen ninguna posibilidad de especificar codificación de salida a continuación, en cuyo caso se utilizará la codificación predeterminada para la máquina, y esto es por lo general no UTF-8!

Por lo tanto, en el mejor utilizar FileOutputStream:

Writer writer = new BufferedWriter(new OutputStreamWriter(
     new FileOutputStream(file, true), "UTF-8")); 

Answer 5

Probar: "\ r \ n"

Java 7 ejemplo:

// append = true 
try(PrintWriter output = new PrintWriter(new FileWriter("log.txt",true))) 
{ 
    output.printf("%s\r\n", "NEWLINE"); 
} 
catch (Exception e) {} 

Answer 6

Si estás buscando un método de cortar y pegar que crea y escribe en un archivo, aquí hay uno que escribí que solo toma una cadena entrada. Elimine 'verdadero' de PrintWriter si desea sobrescribir el archivo cada vez.

private static final String newLine = System.getProperty("line.separator"); 

private synchronized void writeToFile(String msg) { 
    String fileName = "c:\\TEMP\\runOutput.txt"; 
    PrintWriter printWriter = null; 
    File file = new File(fileName); 
    try { 
     if (!file.exists()) file.createNewFile(); 
     printWriter = new PrintWriter(new FileOutputStream(fileName, true)); 
     printWriter.write(newLine + msg); 
    } catch (IOException ioex) { 
     ioex.printStackTrace(); 
    } finally { 
     if (printWriter != null) { 
      printWriter.flush(); 
      printWriter.close(); 
     } 
    } 
} 

Answer 7

A partir de Java 7:

definir una ruta de acceso y la cadena que contiene el separador de línea al principio:

Path p = Paths.get("C:\\Users\\first.last\\test.txt"); 
String s = System.lineSeparator() + "New Line!"; 

y luego se puede utilizar uno de los siguientes enfoques:

1. Usando Files.write (pequeños archivos):

   try { 
       Files.write(p, s.getBytes(), StandardOpenOption.APPEND); 
   } catch (IOException e) { 
       System.err.println(e); 
   } 
   

2. Uso Files.newBufferedWriter (archivos de texto):

   try (BufferedWriter writer = Files.newBufferedWriter(p, StandardOpenOption.APPEND)) { 
       writer.write(s); 
   } catch (IOException ioe) { 
       System.err.format("IOException: %s%n", ioe); 
   } 
   

3. Uso Files.newOutputStream (interoperable con java.io API):

   try (OutputStream out = new BufferedOutputStream(Files.newOutputStream(p, StandardOpenOption.APPEND))) { 
       out.write(s.getBytes()); 
   } catch (IOException e) { 
       System.err.println(e); 
   } 
   

4. Uso Files.newByteChannel (al azar archivos de acceso):

   try (SeekableByteChannel sbc = Files.newByteChannel(p, StandardOpenOption.APPEND)) { 
       sbc.write(ByteBuffer.wrap(s.getBytes())); 
   } catch (IOException e) { 
       System.err.println(e); 
   } 
   

5. Uso (archivos de acceso aleatorio): FileChannel.open

   try (FileChannel sbc = FileChannel.open(p, StandardOpenOption.APPEND)) { 
       sbc.write(ByteBuffer.wrap(s.getBytes())); 
   } catch (IOException e) { 
       System.err.println(e); 
   } 
   

detalles acerca de estos métodos se pueden encontrar en el Oracle's tutorial.