Pregunta Cómo agregar texto a un archivo existente en Java


Necesito anexar texto repetidamente a un archivo existente en Java. ¿Cómo puedo hacer eso?


583
2017-10-26 14:43


origen


Respuestas:


¿Estás haciendo esto para fines de registro? Si es así hay varias bibliotecas para esto. Dos de los más populares son Log4j y Volver a iniciar sesión.

Java 7+

Si solo necesitas hacer esto una vez, el Clase de archivos lo hace fácil:

try {
    Files.write(Paths.get("myfile.txt"), "the text".getBytes(), StandardOpenOption.APPEND);
}catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Cuidadoso: El enfoque anterior arrojará un NoSuchFileException si el archivo aún no existe Tampoco agrega automáticamente una nueva línea (que a menudo desea al agregar a un archivo de texto). La respuesta de Steve Chambers cubre cómo puedes hacer esto con Files clase.

Sin embargo, si va a escribir en el mismo archivo muchas veces, lo anterior tiene que abrir y cerrar el archivo en el disco muchas veces, lo cual es una operación lenta. En este caso, un escritor amortiguado es mejor:

try(FileWriter fw = new FileWriter("myfile.txt", true);
    BufferedWriter bw = new BufferedWriter(fw);
    PrintWriter out = new PrintWriter(bw))
{
    out.println("the text");
    //more code
    out.println("more text");
    //more code
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Notas:

  • El segundo parámetro para el FileWriter El constructor le dirá que se anexe al archivo, en lugar de escribir un nuevo archivo. (Si el archivo no existe, se creará).
  • Usando un BufferedWriter es recomendado para un escritor costoso (como FileWriter)
  • Usando un PrintWriter te da acceso a println sintaxis a la que probablemente estés acostumbrado desde System.out.
  • Pero el BufferedWriter y PrintWriter envoltorios no son estrictamente necesarios.

Java anterior

try {
    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("myfile.txt", true)));
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Manejo de excepciones

Si necesita una sólida gestión de excepciones para Java antiguo, se vuelve muy detallado:

FileWriter fw = null;
BufferedWriter bw = null;
PrintWriter out = null;
try {
    fw = new FileWriter("myfile.txt", true);
    bw = new BufferedWriter(fw);
    out = new PrintWriter(bw);
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}
finally {
    try {
        if(out != null)
            out.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(bw != null)
            bw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(fw != null)
            fw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
}

668
2017-10-26 14:47



Puedes usar fileWriter con una bandera configurada para true para agregar

try
{
    String filename= "MyFile.txt";
    FileWriter fw = new FileWriter(filename,true); //the true will append the new data
    fw.write("add a line\n");//appends the string to the file
    fw.close();
}
catch(IOException ioe)
{
    System.err.println("IOException: " + ioe.getMessage());
}

151
2017-10-26 14:48



¿No deberían todas las respuestas aquí con los bloques try / catch tener las piezas .close () contenidas en un bloque finally?

Ejemplo de respuesta marcada:

PrintWriter out = null;
try {
    out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)));
    out.println("the text");
}catch (IOException e) {
    System.err.println(e);
}finally{
    if(out != null){
        out.close();
    }
} 

Además, a partir de Java 7, puede usar un declaración try-with-resources. No se requiere un bloqueo final para cerrar los recursos declarados porque se maneja automáticamente y también es menos detallado:

try(PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)))) {
    out.println("the text");
}catch (IOException e) {
    System.err.println(e);
}

64
2018-02-24 15:48



Editar - A partir de Apache Commons 2.1, la forma correcta de hacerlo es:

FileUtils.writeStringToFile(file, "String to append", true);

Adapte la solución de @Kip para incluir el cierre correcto del archivo finalmente:

public static void appendToFile(String targetFile, String s) throws IOException {
    appendToFile(new File(targetFile), s);
}

public static void appendToFile(File targetFile, String s) throws IOException {
    PrintWriter out = null;
    try {
        out = new PrintWriter(new BufferedWriter(new FileWriter(targetFile, true)));
        out.println(s);
    } finally {
        if (out != null) {
            out.close();
        }
    }
}


39
2017-12-03 13:41



Asegúrese de que la transmisión se cierre correctamente en todos los escenarios.

Es un poco alarmante cómo muchas de estas respuestas dejan el archivo manejado abierto en caso de error. La respuesta https://stackoverflow.com/a/15053443/2498188 está en el dinero, pero solo porque BufferedWriter() no puede tirar. Si pudiera, entonces una excepción dejaría el FileWriter objeto abierto.

Una forma más general de hacer esto que no le importa si BufferedWriter() puede lanzar:

  PrintWriter out = null;
  BufferedWriter bw = null;
  FileWriter fw = null;
  try{
     fw = new FileWriter("outfilename", true);
     bw = new BufferedWriter(fw);
     out = new PrintWriter(bw);
     out.println("the text");
  }
  catch( IOException e ){
     // File writing/opening failed at some stage.
  }
  finally{
     try{
        if( out != null ){
           out.close(); // Will close bw and fw too
        }
        else if( bw != null ){
           bw.close(); // Will close fw too
        }
        else if( fw != null ){
           fw.close();
        }
        else{
           // Oh boy did it fail hard! :3
        }
     }
     catch( IOException e ){
        // Closing the file writers failed for some obscure reason
     }
  }

Editar:

A partir de Java 7, la forma recomendada es usar "probar con recursos" y dejar que la JVM se encargue de ello:

  try(    FileWriter fw = new FileWriter("outfilename", true);
          BufferedWriter bw = new BufferedWriter(fw);
          PrintWriter out = new PrintWriter(bw)){
     out.println("the text");
  }  
  catch( IOException e ){
      // File writing/opening failed at some stage.
  }

19
2017-09-11 16:50



Para expandir ligeramente en La respuesta de Kip, aquí hay un método simple de Java 7+ para agregar un nueva línea a un archivo, crearlo si no existe ya:

try {
    final Path path = Paths.get("path/to/filename.txt");
    Files.write(path, Arrays.asList("New line to append"), StandardCharsets.UTF_8,
        Files.exists(path) ? StandardOpenOption.APPEND : StandardOpenOption.CREATE);
} catch (final IOException ioe) {
    // Add your own exception handling...
}

Nota: Lo anterior usa el Files.write sobrecarga que escribe líneas de texto a un archivo (es decir, similar a printlnmando). Para simplemente escribir texto hasta el final (es decir, similar a print comando), una alternativa Files.write se puede usar sobrecarga, pasando en una matriz de bytes (p. "mytext".getBytes(StandardCharsets.UTF_8))


15
2018-06-01 08:03



En Java-7 también se puede hacer de ese tipo:

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

// ---------------------

Path filePath = Paths.get("someFile.txt");
if (!Files.exists(filePath)) {
    Files.createFile(filePath);
}
Files.write(filePath, "Text to be added".getBytes(), StandardOpenOption.APPEND);

13
2018-04-05 11:03



Muestra, usando guayaba:

File to = new File("C:/test/test.csv");

for (int i = 0; i < 42; i++) {
    CharSequence from = "some string" + i + "\n";
    Files.append(from, to, Charsets.UTF_8);
}

6
2018-06-04 19:17



Esto se puede hacer en una línea de código. Espero que esto ayude :)

Files.write(Paths.get(fileName), msg.getBytes(), StandardOpenOption.APPEND);

6
2017-08-06 17:38



java 7+

En mi humilde opinión ya que soy fanático de Java simple, sugeriría algo que es una combinación de las respuestas antes mencionadas. Tal vez llego tarde a la fiesta. Aquí está el código:

 String sampleText = "test" +  System.getProperty("line.separator");
 Files.write(Paths.get(filePath), sampleText.getBytes(StandardCharsets.UTF_8), 
 StandardOpenOption.CREATE, StandardOpenOption.APPEND);

Si el archivo no existe, lo crea y si ya existe, agrega el texto de ejemplo al archivo existente. Al usar esto, le evita agregar librerías innecesarias a su classpath.


6
2018-02-09 06:59



Solo agrego pequeños detalles:

    new FileWriter("outfilename", true)

2.nd parámetro (verdadero) es una característica (o, interfaz) llamada appendable (http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html) Es responsable de poder agregar algún contenido al final de un archivo / secuencia en particular. Esta interfaz se implementa desde Java 1.5. Cada objeto (es decir BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer) con esta interfaz se puede utilizar para agregar contenido

En otras palabras, puede agregar algo de contenido a su archivo gzip o algún proceso http


5
2017-12-13 10:56