So hängen Sie Text an eine vorhandene Datei in Java an

Ich muss wiederholt Text an eine vorhandene Datei in Java anhängen. Wie mache ich das?

Tun Sie dies zu Protokollierungszwecken? Wenn ja, gibt es dafür mehrere Bibliotheken . Zwei der beliebtesten sind Log4j und Logback .

Java 7+

Wenn Sie dies nur einmal tun müssen, macht die Files-Klasse dies einfach:

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

^{Vorsicht : Der obige Ansatz NoSuchFileExceptionlöst a aus, wenn die Datei noch nicht vorhanden ist. Außerdem wird eine neue Zeile nicht automatisch angehängt (was häufig beim Anhängen an eine Textdatei gewünscht wird). Steve Chambers 'Antwort beschreibt, wie man das mit dem FilesUnterricht machen kann.}

Wenn Sie jedoch mehrmals in dieselbe Datei schreiben, muss die oben genannte Datei auf der Festplatte mehrmals geöffnet und geschlossen werden. Dies ist ein langsamer Vorgang. In diesem Fall ist ein gepufferter Writer besser:

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
}

Anmerkungen:

• Der zweite Parameter des FileWriterKonstruktors weist ihn an, an die Datei anzuhängen, anstatt eine neue Datei zu schreiben. (Wenn die Datei nicht vorhanden ist, wird sie erstellt.)
• Die Verwendung von a BufferedWriterwird für einen teuren Schriftsteller (z. B. FileWriter) empfohlen .
• Mit a erhalten PrintWriterSie Zugriff auf die printlnSyntax, an die Sie wahrscheinlich gewöhnt sind System.out.
• Aber die BufferedWriterund PrintWriterWrapper sind nicht unbedingt notwendig.

Älteres Java

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
}

Ausnahmebehandlung

Wenn Sie eine robuste Ausnahmebehandlung für älteres Java benötigen, wird es sehr ausführlich:

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

Sie können fileWritermit einem Flag truezum Anhängen verwenden.

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

Sollten nicht alle Antworten hier mit Try / Catch-Blöcken die .close () - Teile enthalten, die in einem finally-Block enthalten sind?

Beispiel für eine markierte Antwort:

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

Ab Java 7 können Sie auch eine Try-with-Resources-Anweisung verwenden . Zum Schließen der deklarierten Ressource (n) ist kein endgültiger Block erforderlich, da dieser automatisch behandelt wird und auch weniger ausführlich ist:

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

Bearbeiten - Ab Apache Commons 2.1 ist der richtige Weg, dies zu tun:

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

Ich habe die Lösung von @ Kip so angepasst, dass die Datei endgültig geschlossen wird:

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

Um die Antwort von Kip etwas zu erweitern , finden Sie hier eine einfache Java 7+ -Methode, mit der Sie eine neue Zeile an eine Datei anhängen und diese erstellen können, falls sie noch nicht vorhanden ist :

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

Hinweis: Die oben genannten Verwendungen der Files.writeÜberlastung , die schreibt Zeilen von Text in eine Datei (dh ähnlich wie ein printlnBefehl). Um nur Text bis zum Ende zu schreiben (dh ähnlich einem printBefehl), kann eine alternative Files.writeÜberladung verwendet werden, die ein Byte-Array (z "mytext".getBytes(StandardCharsets.UTF_8). B. ) übergibt .

Stellen Sie sicher, dass der Stream in allen Szenarien ordnungsgemäß geschlossen wird.

Es ist etwas alarmierend, wie viele dieser Antworten das Dateihandle im Fehlerfall offen lassen. Die Antwort https://stackoverflow.com/a/15053443/2498188 ist auf dem Geld, aber nur, weil BufferedWriter()nicht werfen kann. Wenn dies möglich wäre, würde eine Ausnahme das FileWriterObjekt offen lassen.

Eine allgemeinere Methode, die sich nicht darum kümmert, ob BufferedWriter()sie werfen kann:

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

Bearbeiten:

Ab Java 7 wird empfohlen, "mit Ressourcen versuchen" zu verwenden und die JVM damit umgehen zu lassen:

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

In Java-7 kann dies auch folgendermaßen geschehen:

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

Java 7+

Meiner bescheidenen Meinung nach würde ich, da ich ein Fan von einfachem Java bin, etwas vorschlagen, das eine Kombination der oben genannten Antworten ist. Vielleicht komme ich zu spät zur Party. Hier ist der Code:

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

Wenn die Datei nicht vorhanden ist, wird sie erstellt und wenn sie bereits vorhanden ist, wird der sampleText an die vorhandene Datei angehängt . Auf diese Weise können Sie Ihrem Klassenpfad keine unnötigen Bibliotheken hinzufügen.

Dies kann in einer Codezeile erfolgen. Hoffe das hilft :)

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

Verwenden von java.nio. Dateien zusammen mit 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();

Dadurch wird eine BufferedWriterVerwendung von Dateien erstellt, die StandardOpenOptionParameter akzeptiert , und eine automatische Spülung PrintWriteraus dem Ergebnis BufferedWriter. PrintWriterDie println()Methode kann dann aufgerufen werden, um in die Datei zu schreiben.

Die StandardOpenOptionin diesem Code verwendeten Parameter: Öffnet die Datei zum Schreiben, hängt sie nur an die Datei an und erstellt die Datei, wenn sie nicht vorhanden ist.

Paths.get("path here")kann durch ersetzt werden new File("path here").toPath(). Und Charset.forName("charset name")kann modifiziert werden, um das gewünschte aufzunehmen Charset.

Ich füge nur kleine Details hinzu:

    new FileWriter("outfilename", true)

2.nd Parameter (true) ist eine Funktion (oder Schnittstelle), die als anhängbar bezeichnet wird ( http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html ). Es ist dafür verantwortlich, dass am Ende einer bestimmten Datei / eines bestimmten Streams Inhalte hinzugefügt werden können. Diese Schnittstelle ist seit Java 1.5 implementiert. Jedes Objekt (dh BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer ) mit dieser Schnittstelle kann zum Hinzufügen von Inhalten verwendet werden

Mit anderen Worten, Sie können Ihrer komprimierten Datei Inhalte oder einen http-Prozess hinzufügen

Beispiel mit Guave:

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

Versuchen Sie es mit bufferFileWriter.append, es funktioniert bei mir.

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

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

Dies wird tun, was Sie beabsichtigen ..

Besser, Try-with-Resources zu verwenden, als all das Geschäft vor Java 7

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

Wenn wir Java 7 und höher verwenden und auch den Inhalt kennen, der der Datei hinzugefügt (angehängt) werden soll, können wir die newBufferedWriter- Methode im NIO-Paket verwenden.

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

Es gibt einige Punkte zu beachten:

1. Es ist immer eine gute Angewohnheit, die Zeichensatzcodierung anzugeben, und dafür haben wir eine Konstante in der Klasse StandardCharsets.
2. Der Code verwendet eine try-with-resourceAnweisung, in der Ressourcen nach dem Versuch automatisch geschlossen werden.

OP hat zwar nicht gefragt, aber nur für den Fall, dass wir nach Zeilen mit einem bestimmten Schlüsselwort suchen möchten, z. B. können confidentialwir Stream-APIs in Java verwenden:

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

FileOutputStream fos = new FileOutputStream("File_Name", true);
fos.write(data);

Mit true können die Daten in der vorhandenen Datei angehängt werden. Wenn wir schreiben werden

FileOutputStream fos = new FileOutputStream("File_Name");

Die vorhandene Datei wird überschrieben. Gehen Sie also zum ersten Ansatz.

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

    }

}

FileOutputStream stream = new FileOutputStream(path, true);
try {

    stream.write(

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

    );

} finally {
    stream.close();
}

Dann fangen Sie eine IOException irgendwo stromaufwärts ab.

Erstellen Sie eine Funktion an einer beliebigen Stelle in Ihrem Projekt und rufen Sie diese Funktion einfach dort auf, wo Sie sie benötigen.

Leute, ihr müsst euch daran erinnern, dass ihr aktive Threads aufruft, die ihr nicht asynchron aufruft, und da es wahrscheinlich gute 5 bis 10 Seiten wären, um es richtig zu machen. Warum verbringen Sie nicht mehr Zeit mit Ihrem Projekt und vergessen, alles zu schreiben, was bereits geschrieben wurde? Richtig

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

Drei Zeilen Code zwei wirklich, da die dritte tatsächlich Text anfügt. : P.

Bibliothek

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

Code

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

Sie können dies auch versuchen:

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
}

Ich könnte das Apache Commons-Projekt vorschlagen . Dieses Projekt bietet bereits einen Rahmen, um das zu tun, was Sie benötigen (dh eine flexible Filterung von Sammlungen).

Mit der folgenden Methode können Sie Text an eine Datei anhängen:

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

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

Es ist nicht effizient, funktioniert aber gut. Zeilenumbrüche werden korrekt behandelt und eine neue Datei wird erstellt, falls noch keine vorhanden ist.

Dieser Code erfüllt Ihre Anforderungen:

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

Im Fall , dass Sie einen Text in bestimmten Zeilen ADD Sie zunächst die gesamte Datei lesen können, fügen Sie den Text , wo immer Sie wollen , und dann überschreibt alles wie in dem folgenden Code:

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

Meine Antwort:

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
}

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

Sie können den folgenden Code verwenden, um den Inhalt der Datei anzuhängen:

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

1.7 Ansatz:

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