Cómo agregar texto a un archivo existente en Java

683

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

Flyingfromchina
fuente

Respuestas:

793

¿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 Logback .

Java 7+

Si solo necesita hacer esto una vez, la clase 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
}

Cuidado : el enfoque anterior arrojará un NoSuchFileExceptionsi el archivo aún no existe. Tampoco agrega una nueva línea automáticamente (que a menudo desea cuando se agrega a un archivo de texto). La respuesta de Steve Chambers cubre cómo podrías hacer esto con la Filesclase.

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 protegido 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 FileWriterconstructor le dirá que se agregue al archivo, en lugar de escribir un nuevo archivo. (Si el archivo no existe, se creará).
  • BufferedWriterSe recomienda usar a para un escritor costoso (como FileWriter).
  • El uso de PrintWriterle da acceso a la printlnsintaxis a la que probablemente esté acostumbrado System.out.
  • Pero los envoltorios BufferedWritery PrintWriterno son estrictamente necesarios.

Java antiguo

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 un manejo robusto de excepciones para Java más 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
    }
}
Dormir
fuente
31
Debería usar java7 try-with-resources o poner close () en un bloque finalmente, para asegurarse de que el archivo esté cerrado en caso de excepción
Svetlin Zarev
1
actualizado con la sintaxis de Java 7. El manejo de excepciones todavía se deja como un ejercicio para el lector, pero dejó el comentario más claro.
Kip
3
Imaginemos que new BufferedWriter(...)arroja una excepción; ¿ FileWriterSe cerrará el? Supongo que no se cerrará, porque el close()método (en condiciones normales) se invocará en el outobjeto, que en este caso no se inicializará, por lo que en realidad el close()método no se invocará -> el archivo se abrirá, pero No se cerrará. Entonces, en mi humilde opinión, la trydeclaración debería tener este aspecto ¡¡ try(FileWriter fw = new FileWriter("myFile.txt")){ Print writer = new ....//code goes here } Y debería hacerlo flush()el escritor antes de salir del trybloque !!!
Svetlin Zarev
55
Precaución, el ejemplo "Olva java" no cerrará correctamente la transmisión si se lanza una excepción dentro del bloque try.
Emily L.
1
Un par de posibles "problemas" con el método Java 7: (1) Si el archivo aún no existe, StandardOpenOption.APPENDno lo creará, algo así como una falla silenciosa ya que tampoco arrojará una excepción. (2) El uso .getBytes()significará que no hay caracteres de retorno antes o después del texto adjunto. He agregado una respuesta alternativa para abordar estos.
Steve Chambers
166

Se puede usar fileWritercon una bandera establecida en 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());
}
Polo Norte
fuente
99
closedebe colocarse en finallybloque tal como se muestra en la respuesta de @etech en caso de que se produzca una excepción entre la creación de FileWriter y la invocación de cierre.
Pshemo
55
Buena respuesta, aunque es mejor usar System.getProperty ("line.separator") para una nueva línea en lugar de "\ n".
Henry Zhu
@Decoded He revertido su edición en esta respuesta, ya que no se compila.
Kip
@Kip, ¿Cuál fue el problema? Debo haber ingresado un "error tipográfico".
Decodificado el
2
¿Qué tal probar con recursos? try(FileWriter fw = new FileWriter(filename,true)){ // Whatever }catch(IOException ex){ ex.printStackTrace(); }
php_coder_3809625
72

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

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 una declaración de prueba con recursos . No se requiere finalmente un bloque 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);
}
etech
fuente
1
Cuando outsale del alcance, se cierra automáticamente cuando se recolecta basura, ¿verdad? En su ejemplo con el finallybloque, creo que realmente necesita otro try / catch anidado out.close()si no recuerdo mal. ¡La solución Java 7 es bastante ingeniosa! (No he estado haciendo cualquier dev Java desde Java 6, así que estaba familiarizado con ese cambio.)
Kip
1
@Kip Nope, salir de alcance no hace nada en Java. El archivo se cerrará en algún momento aleatorio en el futuro. (probablemente cuando se cierra el programa)
Navin
@etech ¿El segundo enfoque necesitará el flushmétodo?
syfantid
43

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

ripper234
fuente
44
Oh gracias. Me divertía la complejidad de todas las otras respuestas. Realmente no entiendo por qué a la gente le gusta complicar su vida (de desarrollador).
Alphaaa
El problema con este enfoque es que abre y cierra el flujo de salida cada vez. Dependiendo de qué y con qué frecuencia escriba en su archivo, esto podría resultar en una sobrecarga ridícula.
Buffalo
@Buffalo tiene razón. Pero siempre puede usar StringBuilder para construir fragmentos grandes (que vale la pena escribir) antes de escribirlos en un archivo.
Konstantin K
32

Para ampliar ligeramente la respuesta de Kip , aquí hay un método simple de Java 7+ para agregar una nueva línea a un archivo, creándolo si aún no existe :

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 la Files.writesobrecarga que escribe líneas de texto en un archivo (es decir, similar a un printlncomando). Para escribir texto hasta el final (es decir, similar a un printcomando), Files.writese puede utilizar una sobrecarga alternativa , pasando una matriz de bytes (por ejemplo "mytext".getBytes(StandardCharsets.UTF_8)).

Steve Chambers
fuente
¿Necesita verificar si el archivo existe? Pensé que .CREATEhace el trabajo por ti.
LearningToJava
22

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

Es un poco alarmante cuántas de estas respuestas dejan el identificador de archivo abierto en caso de error. La respuesta https://stackoverflow.com/a/15053443/2498188 está en el dinero, pero solo porque BufferedWriter()no se puede lanzar. Si pudiera, una excepción dejaría el FileWriterobjeto 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.
  }
Emily L.
fuente
+1 para ARM correcto con Java 7. Aquí hay una buena pregunta sobre este tema complicado: stackoverflow.com/questions/12552863/… .
Vadzim
1
Hmm, por alguna razón PrintWriter.close()no se declara como throws IOExceptionen los documentos . Mirando su fuente , el close()método, de hecho, no puede lanzar IOException, porque lo atrapa del flujo subyacente y establece una bandera. Entonces, si está trabajando en el código para el próximo transbordador espacial o un sistema de medición de dosis de rayos X, debe usarlo PrintWriter.checkError()después de intentarlo out.close(). Esto realmente debería haber sido documentado.
Evgeni Sergeev
Si vamos a ser súper paranoicos acerca del cierre, cada uno de ellos XX.close()debería estar en su propio intento / captura, ¿verdad? Por ejemplo, out.close()podría lanzar una excepción, en cuyo caso bw.close()y fw.close()nunca sería llamado, y fwes la que es más crítica para cerrar.
Kip
13

En Java-7 también se puede hacer de este 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);
Tsolak Barseghyan
fuente
2
¿Cuáles son las importaciones requeridas? ¿Qué biblioteca usan estas cosas?
Chetan Bhasin
9

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 muestra al archivo existente. Al usar esto, le ahorra agregar libs innecesarias a su classpath.

Lefteris Bab
fuente
8

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

Files.write(Paths.get(fileName), msg.getBytes(), StandardOpenOption.APPEND);
FlintOff
fuente
1
puede que no sea suficiente :) la mejor versión es Files.write (Paths.get (fileName), msg.getBytes (), StandardOpenOption.APPEND, StandardOpenOption.CREATE);
evg345
6

Usando java.nio. Archivos junto con java.nio.file. StandardOpenOption

    PrintWriter out = null;
    BufferedWriter bufWriter;

    try{
        bufWriter =
            Files.newBufferedWriter(
                Paths.get("log.txt"),
                Charset.forName("UTF8"),
                StandardOpenOption.WRITE, 
                StandardOpenOption.APPEND,
                StandardOpenOption.CREATE);
        out = new PrintWriter(bufWriter, true);
    }catch(IOException e){
        //Oh, no! Failed to create PrintWriter
    }

    //After successful creation of PrintWriter
    out.println("Text to be appended");

    //After done writing, remember to close!
    out.close();

Esto crea un BufferedWriteruso de archivos, que acepta StandardOpenOptionparámetros, y un enjuague automático PrintWriterdel resultante BufferedWriter. PrintWriterEl println()método de, luego puede ser llamado para escribir en el archivo.

Los StandardOpenOptionparámetros utilizados en este código: abre el archivo para escribir, solo se agrega al archivo y crea el archivo si no existe.

Paths.get("path here")puede ser reemplazado con new File("path here").toPath(). Y Charset.forName("charset name")se puede modificar para acomodar el deseado Charset.

icasdri
fuente
5

Solo agrego un pequeño detalle:

    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 algún contenido a su archivo comprimido o algún proceso http

xhudik
fuente
4

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);
}
dantuch
fuente
13
Este es un consejo horrible. Abre una secuencia en el archivo 42 veces en lugar de una vez.
xehpuk
3
@xehpuk bueno, depende. 42 todavía está bien, si hace que el código sea mucho más legible. 42k no sería aceptable.
dantuch
4

Intenta con bufferFileWriter.append, funciona conmigo.

FileWriter fileWriter;
try {
    fileWriter = new FileWriter(file,true);
    BufferedWriter bufferFileWriter = new BufferedWriter(fileWriter);
    bufferFileWriter.append(obj.toJSONString());
    bufferFileWriter.newLine();
    bufferFileWriter.close();
} catch (IOException ex) {
    Logger.getLogger(JsonTest.class.getName()).log(Level.SEVERE, null, ex);
}
Nadhir Titaouine
fuente
¿Qué es obj.toJSONString () aquí?
Bhaskara Arani
@BhaskaraArani Es solo una cadena, puso un ejemplo de un objeto JSON convertido en una cadena, pero la idea es que podría ser cualquier cadena.
Gherbi Hicham
3
    String str;
    String path = "C:/Users/...the path..../iin.txt"; // you can input also..i created this way :P

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw = new PrintWriter(new FileWriter(path, true));

    try 
    {
       while(true)
        {
            System.out.println("Enter the text : ");
            str = br.readLine();
            if(str.equalsIgnoreCase("exit"))
                break;
            else
                pw.println(str);
        }
    } 
    catch (Exception e) 
    {
        //oh noes!
    }
    finally
    {
        pw.close();         
    }

esto hará lo que pretendes ..

Benjamin Varghese
fuente
3

Es mejor usar try-with-resources que todo ese pre-java 7 finalmente negocio

static void appendStringToFile(Path file, String s) throws IOException  {
    try (BufferedWriter out = Files.newBufferedWriter(file, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        out.append(s);
        out.newLine();
    }
}
mikeyreilly
fuente
3

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 preguntado, 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();
}
akhil_mittal
fuente
una advertencia: cuando se usa BufferedWriter write(String string)si uno espera una nueva línea después de cada cadena escrita, newLine()debe llamarse
yongtw123
3
FileOutputStream fos = new FileOutputStream("File_Name", true);
fos.write(data);

el verdadero permite agregar los datos en el archivo existente. Si vamos a escribir

FileOutputStream fos = new FileOutputStream("File_Name");

Sobreescribirá el archivo existente. Así que ve por el primer acercamiento.

shakti kumar
fuente
3
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class Writer {


    public static void main(String args[]){
        doWrite("output.txt","Content to be appended to file");
    }

    public static void doWrite(String filePath,String contentToBeAppended){

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

    }

}
David Charles
fuente
Lo anterior es solo un ejemplo rápido de implementación de la solución presentada en este enlace . Para que pueda copiar y ejecutar el código e inmediatamente ver cómo funciona, asegúrese de que el archivo output.out esté en el mismo directorio que el archivo Writer.java
David Charles
2
FileOutputStream stream = new FileOutputStream(path, true);
try {

    stream.write(

        string.getBytes("UTF-8") // Choose your encoding.

    );

} finally {
    stream.close();
}

Luego tome una IOException en algún lugar aguas arriba.

TiburónAlley
fuente
2

Cree una función en cualquier parte de su proyecto y simplemente llame a esa función donde la necesite.

Chicos, deben recordar que ustedes están llamando hilos activos que no están llamando de forma asincrónica y ya que probablemente sería un buen 5 a 10 páginas para hacerlo bien. ¿Por qué no dedicar más tiempo a su proyecto y olvidarse de escribir cualquier cosa ya escrita? Correctamente

    //Adding a static modifier would make this accessible anywhere in your app

    public Logger getLogger()
    {
       return java.util.logging.Logger.getLogger("MyLogFileName");
    }
    //call the method anywhere and append what you want to log 
    //Logger class will take care of putting timestamps for you
    //plus the are ansychronously done so more of the 
    //processing power will go into your application

    //from inside a function body in the same class ...{...

    getLogger().log(Level.INFO,"the text you want to append");

    ...}...
    /*********log file resides in server root log files********/

tres líneas de código dos realmente ya que la tercera realmente agrega texto. :PAGS

Netcfmx
fuente
2

Biblioteca

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

Código

public void append()
{
    try
    {
        String path = "D:/sample.txt";

        File file = new File(path);

        FileWriter fileWriter = new FileWriter(file,true);

        BufferedWriter bufferFileWriter  = new BufferedWriter(fileWriter);

        fileWriter.append("Sample text in the file to append");

        bufferFileWriter.close();

        System.out.println("User Registration Completed");

    }catch(Exception ex)
    {
        System.out.println(ex);
    }
}
absiddiqueLive
fuente
2

También puedes probar esto :

JFileChooser c= new JFileChooser();
c.showOpenDialog(c);
File write_file = c.getSelectedFile();
String Content = "Writing into file"; //what u would like to append to the file



try 
{
    RandomAccessFile raf = new RandomAccessFile(write_file, "rw");
    long length = raf.length();
    //System.out.println(length);
    raf.setLength(length + 1); //+ (integer value) for spacing
    raf.seek(raf.length());
    raf.writeBytes(Content);
    raf.close();
} 
catch (Exception e) {
    //any exception handling method of ur choice
}
aashima
fuente
1

Podría sugerir el proyecto apache commons . Este proyecto ya proporciona un marco para hacer lo que necesita (es decir, filtrado flexible de colecciones).

Tom Drake
fuente
1

El siguiente método le permite agregar texto a algún archivo:

private void appendToFile(String filePath, String text)
{
    PrintWriter fileWriter = null;

    try
    {
        fileWriter = new PrintWriter(new BufferedWriter(new FileWriter(
                filePath, true)));

        fileWriter.println(text);
    } catch (IOException ioException)
    {
        ioException.printStackTrace();
    } finally
    {
        if (fileWriter != null)
        {
            fileWriter.close();
        }
    }
}

Alternativamente usando FileUtils:

public static void appendToFile(String filePath, String text) throws IOException
{
    File file = new File(filePath);

    if(!file.exists())
    {
        file.createNewFile();
    }

    String fileContents = FileUtils.readFileToString(file);

    if(file.length() != 0)
    {
        fileContents = fileContents.concat(System.lineSeparator());
    }

    fileContents = fileContents.concat(text);

    FileUtils.writeStringToFile(file, fileContents);
}

No es eficiente pero funciona bien. Los saltos de línea se manejan correctamente y se crea un nuevo archivo si aún no existía.

BullyWiiPlaza
fuente
1

Este código satisfará su necesidad:

   FileWriter fw=new FileWriter("C:\\file.json",true);
   fw.write("ssssss");
   fw.close();
Shalini Baranwal
fuente
¿¿Umm que?? Esto sobrescribirá el archivo.
javadba
1

En caso de que desee AGREGAR ALGUNOS TEXTOS EN LÍNEAS ESPECÍFICAS , primero puede leer el archivo completo, agregar el texto donde desee y luego sobrescribir todo, como en el siguiente código:

public static void addDatatoFile(String data1, String data2){


    String fullPath = "/home/user/dir/file.csv";

    File dir = new File(fullPath);
    List<String> l = new LinkedList<String>();

    try (BufferedReader br = new BufferedReader(new FileReader(dir))) {
        String line;
        int count = 0;

        while ((line = br.readLine()) != null) {
            if(count == 1){
                //add data at the end of second line                    
                line += data1;
            }else if(count == 2){
                //add other data at the end of third line
                line += data2;
            }
            l.add(line);
            count++;
        }
        br.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }       
    createFileFromList(l, dir);
}

public static void createFileFromList(List<String> list, File f){

    PrintWriter writer;
    try {
        writer = new PrintWriter(f, "UTF-8");
        for (String d : list) {
            writer.println(d.toString());
        }
        writer.close();             
    } catch (FileNotFoundException | UnsupportedEncodingException e) {
        e.printStackTrace();
    }
}
lfvv
fuente
0

Mi respuesta:

JFileChooser chooser= new JFileChooser();
chooser.showOpenDialog(chooser);
File file = chooser.getSelectedFile();
String Content = "What you want to append to file";

try 
{
    RandomAccessFile random = new RandomAccessFile(file, "rw");
    long length = random.length();
    random.setLength(length + 1);
    random.seek(random.length());
    random.writeBytes(Content);
    random.close();
} 
catch (Exception exception) {
    //exception handling
}
userAsh
fuente
0
/**********************************************************************
 * it will write content to a specified  file
 * 
 * @param keyString
 * @throws IOException
 *********************************************************************/
public static void writeToFile(String keyString,String textFilePAth) throws IOException {
    // For output to file
    File a = new File(textFilePAth);

    if (!a.exists()) {
        a.createNewFile();
    }
    FileWriter fw = new FileWriter(a.getAbsoluteFile(), true);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.append(keyString);
    bw.newLine();
    bw.close();
}// end of writeToFile()
Mihir Patel
fuente
-1

Puede usar el código siguiente para agregar el contenido en el archivo:

 String fileName="/home/shriram/Desktop/Images/"+"test.txt";
  FileWriter fw=new FileWriter(fileName,true);    
  fw.write("here will be you content to insert or append in file");    
  fw.close(); 
  FileWriter fw1=new FileWriter(fileName,true);    
 fw1.write("another content will be here to be append in the same file");    
 fw1.close(); 
shriram
fuente
-1

1.7 Enfoque:

void appendToFile(String filePath, String content) throws IOException{

    Path path = Paths.get(filePath);

    try (BufferedWriter writer = 
            Files.newBufferedWriter(path, 
                    StandardOpenOption.APPEND)) {
        writer.newLine();
        writer.append(content);
    }

    /*
    //Alternative:
    try (BufferedWriter bWriter = 
            Files.newBufferedWriter(path, 
                    StandardOpenOption.WRITE, StandardOpenOption.APPEND);
            PrintWriter pWriter = new PrintWriter(bWriter)
            ) {
        pWriter.println();//to have println() style instead of newLine();   
        pWriter.append(content);//Also, bWriter.append(content);
    }*/
}
Sawan Patwari
fuente