Cómo agregar texto a un archivo existente en Java


Answers

Puede usar fileWriter con un fileWriter establecido 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());
}
Question

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




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

Chicos, deben recordar que están llamando a hilos activos que no están llamando de forma asíncrona y dado que probablemente serían unas buenas 5 a 10 páginas para hacerlo bien. ¿Por qué no dedicar más tiempo a su proyecto y olvidarse de escribir algo ya escrito? 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 en realidad agrega texto. :PAG




/**********************************************************************
 * 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()



Este código satisfará tu necesidad:

   FileWriter fw=new FileWriter("C:\\file.json",true);
   fw.write("ssssss");
   fw.close();



Si utilizamos Java 7 y newBufferedWriter posteriores 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 una buena costumbre especificar la codificación del conjunto de caracteres y para eso tenemos constantes en la clase StandardCharsets .
  2. El código usa la declaración try-with-resource en la que los recursos se cierran automáticamente después de la prueba.

Aunque OP no ha preguntado, pero en caso de que deseemos 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();
}



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



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
}



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 pueden usar para agregar contenido

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




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



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

    }

}



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




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



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
}



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

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

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




Links