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

683

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

Fliegen aus China
quelle

Antworten:

792

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
    }
}
Pennen
quelle
31
Sie sollten entweder Java7 Try-with-Resources verwenden oder close () in einen finally-Block einfügen, um sicherzustellen, dass die Datei im Ausnahmefall geschlossen wird
Svetlin Zarev
1
aktualisiert mit Java 7 Syntax. Die Ausnahmebehandlung bleibt weiterhin als Übung für den Leser, machte den Kommentar jedoch klarer.
Kip
3
Stellen wir uns vor, das new BufferedWriter(...)löst eine Ausnahme aus. Wird das FileWritergeschlossen sein? Ich denke, dass es nicht geschlossen wird, weil die close()Methode (unter normalen Bedingungen) für das outObjekt aufgerufen wird, was in diesem Fall nicht initialisiert wird - also wird die close()Methode tatsächlich nicht aufgerufen -> die Datei wird geöffnet, aber wird nicht geschlossen. Also IMHO sollte die tryAussage so aussehen try(FileWriter fw = new FileWriter("myFile.txt")){ Print writer = new ....//code goes here } Und er sollte flush()der Autor, bevor er den tryBlock verlässt !!!
Svetlin Zarev
5
Achtung, das Beispiel "Älteres Java" schließt den Stream nicht richtig, wenn eine Ausnahme im try-Block ausgelöst wird.
Emily L.
1
Ein paar mögliche "Fallstricke" mit der Java 7-Methode: (1) Wenn die Datei noch nicht vorhanden ist, StandardOpenOption.APPENDwird sie nicht erstellt - wie ein stiller Fehler, da sie auch keine Ausnahme auslöst. (2) Verwenden .getBytes()bedeutet, dass vor oder nach dem angehängten Text kein Rückgabezeichen steht. Habe eine alternative Antwort hinzugefügt , um diese zu beheben.
Steve Chambers
166

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());
}
Nordpol
quelle
9
closesollte finallywie in der Antwort von @ etech gezeigt in einen Block eingefügt werden, falls zwischen der Erstellung von FileWriter und dem Aufrufen von close eine Ausnahme ausgelöst wird.
Pshemo
5
Gute Antwort, obwohl es besser ist, System.getProperty ("line.separator") für eine neue Zeile als "\ n" zu verwenden.
Henry Zhu
@Decoded Ich habe Ihre Bearbeitung dieser Antwort zurückgesetzt, da sie nicht kompiliert wird.
Kip
@ Kip, was war das Problem? Ich muss einen "Tippfehler" eingegeben haben.
Entschlüsselt
2
Wie wäre es mit Versuchen mit Ressourcen? try(FileWriter fw = new FileWriter(filename,true)){ // Whatever }catch(IOException ex){ ex.printStackTrace(); }
php_coder_3809625
72

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);
}
etech
quelle
1
Wenn outder Gültigkeitsbereich verlassen wird, wird es automatisch geschlossen, wenn Müll gesammelt wird, oder? In Ihrem Beispiel mit dem finallyBlock denke ich, dass Sie tatsächlich einen weiteren verschachtelten Versuch / Fang benötigen, out.close()wenn ich mich richtig erinnere. Die Java 7-Lösung ist ziemlich schick! (Ich habe seit Java 6 keinen Java-Entwickler mehr gemacht, daher war ich mit dieser Änderung nicht vertraut.)
Kip
1
@Kip Nein, das Verlassen des Gültigkeitsbereichs führt in Java zu nichts. Die Datei wird in Zukunft zu einem zufälligen Zeitpunkt geschlossen. (wahrscheinlich, wenn das Programm endet)
Navin
@etech Benötigt der zweite Ansatz die flushMethode?
Syfantid
43

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

ripper234
quelle
4
Oh danke. Ich war amüsiert über die Komplexität aller anderen Antworten. Ich verstehe wirklich nicht, warum Leute ihr (Entwickler-) Leben gerne komplizieren.
Alphaaa
Das Problem bei diesem Ansatz ist, dass der Ausgabestream jedes Mal geöffnet und geschlossen wird. Je nachdem, was und wie oft Sie in Ihre Datei schreiben, kann dies zu einem lächerlichen Overhead führen.
Buffalo
@ Buffalo ist richtig. Sie können StringBuilder jedoch immer zum Erstellen großer Blöcke (die es wert sind, geschrieben zu werden) verwenden, bevor Sie sie in eine Datei schreiben.
Konstantin K
32

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 .

Steve Chambers
quelle
Müssen Sie überprüfen, ob die Datei vorhanden ist? Ich dachte, .CREATEmacht den Job für dich.
LearningToJava
22

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.
  }
Emily L.
quelle
+1 für korrektes ARM mit Java 7. Hier ist eine gute Frage zu diesem kniffligen Thema: stackoverflow.com/questions/12552863/… .
Vadzim
1
Hmm, aus irgendeinem Grund PrintWriter.close()ist nicht wie throws IOExceptionin den Dokumenten deklariert . Wenn man sich die Quelleclose() ansieht, kann die Methode tatsächlich nicht werfen IOException, da sie sie vom zugrunde liegenden Stream abfängt und ein Flag setzt. Wenn Sie also am Code für das nächste Space Shuttle oder ein Röntgendosis-Messsystem arbeiten, sollten Sie ihn PrintWriter.checkError()nach dem Versuch verwenden out.close(). Dies sollte wirklich dokumentiert worden sein.
Evgeni Sergeev
Wenn wir beim Schließen super paranoid sein wollen, sollte jeder von ihnen XX.close()seinen eigenen Versuch / Fang haben, oder? Zum Beispiel out.close()könnte eine Ausnahme ausgelöst werden, in welchem ​​Fall bw.close()und fw.close()würde nie aufgerufen werden, und fwist diejenige, die am kritischsten zu schließen ist.
Kip
13

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);
Tsolak Barseghyan
quelle
2
Was sind die erforderlichen Importe? Welche Bibliothek benutzen diese Dinge?
Chetan Bhasin
9

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.

Lefteris Bab
quelle
8

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

Files.write(Paths.get(fileName), msg.getBytes(), StandardOpenOption.APPEND);
FlintOff
quelle
1
es kann nicht genug sein :) bessere Version ist Files.write (Paths.get (Dateiname), msg.getBytes (), StandardOpenOption.APPEND, StandardOpenOption.CREATE);
evg345
6

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.

icasdri
quelle
5

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

xhudik
quelle
4

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);
}
Dantuch
quelle
13
Das ist ein schrecklicher Rat. Sie öffnen einen Stream für die Datei 42 Mal anstatt einmal.
Xehpuk
3
@ Xehpuk gut, es kommt darauf an. 42 ist immer noch in Ordnung, wenn es den Code viel lesbarer macht. 42k wären nicht akzeptabel.
Dantuch
4

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);
}
Nadhir Titaouine
quelle
Was ist obj.toJSONString () hier?
Bhaskara Arani
@ BhaskaraArani Es ist nur eine Zeichenfolge, er hat ein Beispiel für ein JSON-Objekt eingefügt, das in eine Zeichenfolge konvertiert wurde, aber die Idee ist, dass es eine beliebige Zeichenfolge sein kann.
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();         
    }

Dies wird tun, was Sie beabsichtigen ..

Benjamin Varghese
quelle
3

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

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();
}
akhil_mittal
quelle
eine Einschränkung: Wenn Sie BufferedWriter verwenden und write(String string)eine neue Zeile nach jeder geschriebenen Zeichenfolge erwarten, newLine()sollte dies aufgerufen werden
yongtw123
3
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.

Shakti Kumar
quelle
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
quelle
Das Obige ist nur ein kurzes Beispiel für die Implementierung der unter diesem Link vorgestellten Lösung . Damit Sie den Code kopieren und ausführen können und sofort sehen können, wie er funktioniert, stellen Sie sicher, dass sich die Datei output.out im selben Verzeichnis befindet wie die Datei Writer.java
David Charles
2
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.

SharkAlley
quelle
2

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.

Netcfmx
quelle
2

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);
    }
}
absiddiqueLive
quelle
2

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
}
Aashima
quelle
1

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

Tom Drake
quelle
1

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.

BullyWiiPlaza
quelle
1

Dieser Code erfüllt Ihre Anforderungen:

   FileWriter fw=new FileWriter("C:\\file.json",true);
   fw.write("ssssss");
   fw.close();
Shalini Baranwal
quelle
ähm ... was ?? Dadurch wird die Datei überschrieben .
Javadba
1

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

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
}
userAsh
quelle
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
quelle
-1

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(); 
Shriram
quelle
-1

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