Wie Text in eine vorhandene Datei in Java anhängen

Question

Ich brauche Text anhängen wiederholt an eine vorhandene Datei in Java. Wie kann ich das tun?

Answer 1

Tun Sie dies zur Protokollierung? Wenn ja gibt es mehrere Bibliotheken für diese . Zwei der beliebtesten sind Log4j und Logback .

Java 7 +

Wenn Sie brauchen nur dieses ein Mal zu tun, die Dateien Klasse macht 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
}

^{Sorgfältige : Der obige Ansatz eine NoSuchFileException werfen, wenn die Datei nicht bereits vorhanden ist. Es ist anhängen auch nicht eine neue Zeile automatisch (die man oft wünschen, wenn in einer Textdatei angehängt). Steve Chambers Antwort beschreibt, wie Sie dies mit Files Klasse tun könnte.}

Wenn Sie jedoch viele Male auf die gleiche Datei schreiben wird, hat das oben zu öffnen und die Datei auf der Festplatte viele Male zu schließen, was ein langsamer Vorgang ist. In diesem Fall ist ein gepufferte Schriftsteller 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
}

Weitere Informationen:

• Der zweite Parameter an den Konstruktor FileWriter wird es sagen, um die Datei anzuhängen, anstatt eine neue Datei zu schreiben. (Wenn die Datei nicht existiert, wird er erstellt.)
• ein BufferedWriter Verwendung ist für einen teueren Schriftsteller (wie FileWriter) empfohlen.
• ein PrintWriter Verwendung erhalten Sie Zugriff Syntax println, dass Sie wahrscheinlich von System.out gewohnt sind.
• Aber die BufferedWriter und PrintWriter Wrapper sind nicht unbedingt erforderlich.

---

ältere 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 Handhabung robust Ausnahme benötigen für älteren Java, es wird 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
    }
}

Answer 2

Sie können fileWriter mit einem Flag verwenden auf true, zum Anhängen.

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

Answer 3

Sollte nicht alle Antworten hier mit try / catch-Blöcken haben die .close () Stücke enthalten in einem finally-Block?

Beispiel für deutliche 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();
    }
} 

Auch, wie von Java 7, können Sie eine TRY mit-Ressourcen Aussage . Keine schließlich Block erforderlich zum Schließen der deklarierten Ressource (n), weil es automatisch gehandhabt wird, und ist auch weniger ausführlich:

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

Answer 4

Bearbeiten - wie die Apache Commons 2.1, der richtige Weg, es zu tun ist:

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

I @ Kips Lösung angepasst richtig schließen Schließen der Datei auf schließlich:

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

Answer 5

Zur Erweiterung leicht auf Kip Antwort , hier ist eine einfache Java 7+ Methode eine neue Zeile in eine Datei Erstellen sie anhängen, wenn es nicht bereits 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 verwendet die Files.write Überlastung dass schreibt Linien von Text in eine Datei (dh ähnlich einem println-Befehl). So schreibt nur Text an das Ende (dh ähnlich einen print Befehl), eine Alternative Files.write Überlast verwendet werden kann, in einem Byte-Array Passieren (zB "mytext".getBytes(StandardCharsets.UTF_8)).

Answer 6

Stellen Sie sicher, dass der Strom richtig in allen Szenarien geschlossen wird.

Es ist ein bisschen erschreckend, wie viele dieser Antworten die Datei handhaben offen bei einem Fehler verlassen. Die Antwort https://stackoverflow.com/a/15053443/2498188 ist auf das Geld aber nur, weil BufferedWriter() kann nicht werfen. Wenn es könnte dann würde eine Ausnahme des FileWriter Objekt offen lassen.

Eine allgemeinere Art und Weise, dies zu tun, dass es egal, ob BufferedWriter() 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
     }
  }

Edit:

Wie von Java 7 ist die empfohlene Methode, „versuchen, mit Ressourcen“ zu verwenden, und lassen Sie die JVM mit ihr umgehen:

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

Answer 7

In Java-7 kann auch eine solche Art durchgeführt werden:

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

Answer 8

Java 7 +

In meiner bescheidenen Meinung nach, da ich Fan von einfacher Java bin, würde ich etwas vorschlagen, dass es sich um eine Kombination der genannten Antworten ist. Vielleicht bin ich für die Partei spät. 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 existiert, es schafft es, und wenn bereits vorhanden ist es anhängt die sample an die vorhandene Datei. Mit diesem, erspart Ihnen das Hinzufügen unnötige Libs zu Classpath.

Answer 9

Dies kann in einer Zeile Code erfolgen. Hoffe, das hilft:)

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

Answer 10

java.nio verwenden. Files 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();

Dies erzeugt eine BufferedWriter mit Dateien, die StandardOpenOption Parameter akzeptiert, und eine automatische Spülung PrintWriter aus dem resultierenden BufferedWriter. PrintWriter des println() Verfahren kann dann aufgerufen werden, um die Datei zu schreiben.

Die StandardOpenOption Parameter in diesem Code verwendet: öffnet die Datei zum Schreiben, hängt nur auf die Datei und erstellt die Datei, wenn sie nicht existiert

.

Paths.get("path here") kann mit new File("path here").toPath() ersetzt werden. Und Charset.forName("charset name") modifiziert werden kann, um den gewünschten Charset gerecht zu werden.

Answer 11

ich nur hinzufügen, kleines Detail:

    new FileWriter("outfilename", true)

2.ten Parameter (true) ist eine Funktion (oder Interface) genannt appendable ( http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html ). Es ist verantwortlich für die Möglichkeit, einige Inhalte bis zum Ende des bestimmten Datei / Stream hinzuzufügen. Diese Schnittstelle ist seit Java 1.5 implementiert. Jedes Objekt (dh BufferedWriter, CharArrayWriter, CharBuffer, Filewriter, FilterWriter, LogStream, Output, PipedWriter, Print, Printwriter, String, Stringbuilder, Stringwriter, Writer ) mit dieser Schnittstelle kann für das Hinzufügen von Inhalten verwendet werden

Mit anderen Worten, können Sie einige Inhalte auf Ihre gzipped Datei oder einen http-Prozess

hinzufügen

Answer 12

Beispiel unter Verwendung von Guava:

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

Answer 13

Versuchen Sie, 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);
}

Answer 14

    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 für .. beabsichtigen

Answer 15

besser zu nutzen versuchen-mit-Ressourcen dann alles, was pre-java 7 schließlich Geschäft

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

Answer 16

Wenn wir mit Hilfe von Java 7 und höher und wissen auch, den Inhalt hinzugefügt werden (angehängt) in die Datei wir von newBufferedWriter Methode in NIO-Paket.

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 Gewohnheit charset zu spezifizieren und für, dass wir konstant in der Klasse StandardCharsets.
2. Der Code verwendet try-with-resource Erklärung, in der Ressourcen werden automatisch nach dem Versuch geschlossen.

Obwohl OP hat nicht gefragt, aber nur für den Fall, dass wir für die Linien suchen etwas bestimmtes Schlüsselwort mit z.B. confidential wir Verwendung von Stream-APIs in Java machen können:

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

Answer 17

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

    }

}

Answer 18

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

    stream.write(

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

    );

} finally {
    stream.close();
}

Dann irgendwo stromaufwärts eine IOException fangen.

Answer 19

Erstellen Sie eine Funktion überall in Ihrem Projekt und einfach diese Funktion aufrufen, wo immer Sie es brauchen.

Jungs haben Sie daran denken, dass euch aktiven Threads aufrufen, die Sie nicht asynchron aufrufen und da es wahrscheinlich eine gute 5 bis 10 Seiten sein würde, um es richtig zu erledigen. Warum nicht mehr Zeit für Ihr Projekt verbringen und vergessen Sie alles, was das Schreiben bereits geschrieben. 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 seit dem dritten anhängen tatsächlich Text. : P

Answer 20

  

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

Answer 21

Sie können auch versuchen, diese:

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
}

Answer 22

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

die wahre erlaubt es, die Daten in der vorhandenen Datei anzuhängen. Wenn wir schreiben

FileOutputStream fos = new FileOutputStream("File_Name");

Es wird die vorhandene Datei überschrieben werden soll. So geht für ersten Ansatz.

Answer 23

Ich könnte darauf hindeuten, das Apache Commons Projekt . Dieses Projekt bietet bereits einen Rahmen für das, was Sie benötigen (das heißt flexible Filterung von Sammlungen).

Answer 24

Die folgende Methode lässt Sie hängen Sie Text zu einem gewissen Datei:

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 einwandfrei. Zeilenumbrüche werden korrekt behandelt und eine neue Datei erstellt wird, wenn man noch nicht existiert.

Answer 25

Dieser Code wird erfüllt Ihren Bedarf:

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

Answer 26

Falls Sie möchten ADD Text in bestimmte Zeilen können Sie zunächst die gesamte Datei lesen, fügen Sie den Text, wo immer Sie wollen, und dann alles überschreiben 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();
    }
}

Answer 27

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
}

Answer 28

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

Answer 29

Sie können den folgenden Code verwenden, um den Inhalt in der Datei anhä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(); 

Answer 30

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