Hoe voeg ik tekst toe aan een bestaand bestand in Java?

Ik moet herhaaldelijk tekst toevoegen aan een bestaand bestand in Java. Hoe doe ik dat?

Antwoord 1, autoriteit 100%

Doe je dit voor logboekdoeleinden? Zo ja, dan zijn er verschillende bibliotheken hiervoor. Twee van de meest populaire zijn Log4jen Log terug.

Java 7+

Voor een eenmalige taak, de De klasse Bestandenmaakt dit eenvoudig:

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

Let op: de bovenstaande aanpak genereert een NoSuchFileExceptionals het bestand nog niet bestaat. Het voegt ook niet automatisch een nieuwe regel toe (wat je vaak wilt bij het toevoegen aan een tekstbestand). Een andere benadering is om zowel de opties CREATEals APPENDdoor te geven, waardoor het bestand eerst wordt gemaakt als het nog niet bestaat:

private void write(final String s) throws IOException {
    Files.writeString(
        Path.of(System.getProperty("java.io.tmpdir"), "filename.txt"),
        s + System.lineSeparator(),
        CREATE, APPEND
    );
}

Als u echter vele malen naar hetzelfde bestand wilt schrijven, moeten de bovenstaande fragmenten het bestand op de schijf vele malen openen en sluiten, wat een langzame bewerking is. In dit geval is een BufferedWritersneller:

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
}

Opmerkingen:

• De tweede parameter van de FileWriter-constructor geeft aan dat deze aan het bestand moet worden toegevoegd in plaats van een nieuw bestand te schrijven. (Als het bestand niet bestaat, wordt het aangemaakt.)
• Het gebruik van een BufferedWriterwordt aanbevolen voor een dure schrijver (zoals FileWriter).
• Het gebruik van een PrintWritergeeft u toegang tot de println-syntaxis die u waarschijnlijk gewend bent van System.out.
• Maar de BufferedWriteren PrintWriterwrappers zijn niet strikt noodzakelijk.

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

Afhandeling van uitzonderingen

Als je een robuuste uitzonderingsbehandeling voor oudere Java nodig hebt, wordt het erg uitgebreid:

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

Antwoord 2, autoriteit 21%

Je kunt FileWritergebruiken met een vlag ingesteld op true, om toe te voegen.

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

Antwoord 3, autoriteit 9%

Moeten niet alle antwoorden hier met try/catch-blokken de .close()-stukken bevatten in een definitief blok?

Voorbeeld voor gemarkeerd antwoord:

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

Vanaf Java 7 kunt u ook een try-with gebruiken -bronnenverklaring. Er is geen definitief blok nodig voor het sluiten van de gedeclareerde bron(nen), omdat het automatisch wordt afgehandeld en ook minder uitgebreid is:

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

Antwoord 4, autoriteit 6%

Apache Commons 2.1 gebruiken:

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

Antwoord 5, autoriteit 4%

Beetje uitbreiden op Kip’s antwoord,
hier is een eenvoudige Java 7+ methode om een nieuwe regeltoe te voegen aan een bestand, het aan te maken als het nog niet bestaat:

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

Verdere opmerkingen:

1. Het bovenstaande gebruikt de Files.writeoverbelasting die regelstekst naar een bestand schrijft (dwz vergelijkbaar met een printlncommando). Om gewoon tekst tot het einde te schrijven (dwz vergelijkbaar met een printcommando), een alternatief Files.writeoverbelasting kan worden gebruikt, waarbij een byte-array wordt doorgegeven (bijv. "mytext".getBytes(StandardCharsets.UTF_8)).

2. De optie CREATEwerkt alleen als de opgegeven map al bestaat – als dat niet het geval is, wordt een NoSuchFileExceptiongegenereerd. Indien nodig kan de volgende code worden toegevoegd na het instellen van pathom de directorystructuur te creëren:

   Path pathParent = path.getParent();
   if (!Files.exists(pathParent)) {
       Files.createDirectories(pathParent);
   }
   

Antwoord 6, autoriteit 3%

Zorg ervoor dat de stream in alle scenario’s goed wordt afgesloten.

Het is een beetje verontrustend hoeveel van deze antwoorden de bestandshandle open laten in geval van een fout. Het antwoord https://stackoverflow.com/a/15053443/2498188is op het geld, maar alleen omdat BufferedWriter()kan niet gooien. Als dat zou kunnen, zou een uitzondering het object FileWriteropen laten.

Een meer algemene manier om dit te doen waarbij het niet uitmaakt of BufferedWriter()kan gooien:

 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:

Vanaf Java 7 is de aanbevolen manier om “Probeer middelen” te gebruiken en laat de JVM ermee omgaan:

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

Antwoord 7, Autoriteit 2%

In Java-7 kan ook zo’n soort worden gedaan:

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

Antwoord 8

Java 7 +

In mijn bescheiden mening sinds ik fan van duidelijke java ben, zou ik iets voorstellen dat het een combinatie is van de bovengenoemde antwoorden. Misschien ben ik te laat voor het feest. Hier is de code:

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

Als het bestand niet bestaat, maakt het het en als het al bestaat, voegt het de
Sampletext naar het bestaande bestand. Gebruik dit, bespaart u van het toevoegen van onnodige libs aan uw klassenpad.

Antwoord 9

Dit kan in één regel code worden gedaan. Ik hoop dat dit helpt 🙂

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

Antwoord 10

Ik voeg gewoon een klein detail toe:

   new FileWriter("outfilename", true)

2.nd parameter (true) is een functie (of interface) genaamd toevoegbaar(http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html). Het is verantwoordelijk voor het kunnen toevoegen van inhoud aan het einde van een bepaald bestand/stream. Deze interface is geïmplementeerd sinds Java 1.5. Elk object (dwz BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer) met deze interface kan worden gebruikt voor het toevoegen van inhoud

Met andere woorden, je kunt wat inhoud toevoegen aan je gzipped-bestand, of een http-proces

Antwoord 11

Java.nio gebruiken.Bestandensamen met 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();

Hiermee wordt een BufferedWritermet bestanden, die StandardOpenOptionPARAMETERS en een automatische spoeling PrintWritervan de resulterende BufferedWriter. PrintWriter‘S println()-methode, kan vervolgens worden opgeroepen om naar het bestand te schrijven.

De StandardOpenOptionParameters die in deze code worden gebruikt: Opent het bestand om te schrijven, past alleen toe aan het bestand en maakt het bestand als deze niet bestaat.

Paths.get("path here")Kan worden vervangen door new File("path here").toPath().
En Charset.forName("charset name")kan worden gewijzigd om de gewenste Charsette ontvangen.

Antwoord 12

monster, met 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);
}

Antwoord 13

Probeer met bufferfilnewriter.appdry, het werkt met mij.

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

Antwoord 14

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

Antwoord 15

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

Dit zal doen waarvoor u voorkomt ..

Antwoord 16

U kunt dit ook proberen:

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
}

Antwoord 17

Het is beter om try-with-resources te gebruiken dan al die pre-java 7 eindelijk zaken

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

Antwoord 18

Als we Java 7 en hoger gebruiken en ook weten welke inhoud aan het bestand moet worden toegevoegd (bijgevoegd), kunnen we gebruik maken van newBufferedWriter-methode in NIO-pakket.

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

Er zijn enkele aandachtspunten:

1. Het is altijd een goede gewoonte om tekensetcodering te specificeren en daarvoor hebben we constante StandardCharsetsin de klas.
2. De code gebruikt de instructie try-with-resourcewaarin bronnen automatisch worden gesloten na de try.

Hoewel OP niet heeft gevraagd, maar voor het geval we willen zoeken naar regels met een specifiek trefwoord, b.v. confidentialwe kunnen gebruik maken van stream-API’s in 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();
}

Antwoord 19

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

Hiermee kunt u de gegevens in het bestaande bestand toevoegen. Als we

schrijven

FileOutputStream fos = new FileOutputStream("File_Name");

Het overschrijft het bestaande bestand. Dus ga voor de eerste aanpak.

Antwoord 20

FileOutputStream stream = new FileOutputStream(path, true);
try {
    stream.write(
        string.getBytes("UTF-8") // Choose your encoding.
    );
} finally {
    stream.close();
}

Vang dan een iOException ergens stroomopwaarts.

Antwoord 21

Maak een functie overal in uw project en bel gewoon die functie waar u het ooit nodig hebt.

Jongens die je moet herinneren dat jullie actieve discussies roepen die je niet asynchroon belt en omdat het waarschijnlijk een goede 5 tot 10 pagina’s zou zijn om het goed te doen.
WAAROM NIET MEER MEER tijd aan uw project uitgeven en vergeet het schrijven van iets dat al is geschreven.
Goed

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

drie regels code twee eigenlijk omdat de derde daadwerkelijk tekst toevoegt. 😛

Antwoord 22

Bibliotheek

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

Antwoord 23

Ik zou het apache commons-projectkunnen voorstellen. Dit project biedt al een raamwerk om te doen wat je nodig hebt (d.w.z. flexibel filteren van collecties).

Antwoord 24

Met de volgende methode kunt u tekst aan een bestand toevoegen:

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

alternatief met behulp van 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);
}

Het is niet efficiënt, maar werkt prima. Lijnbrekes worden correct afgehandeld en er wordt nog een nieuw bestand gecreëerd als deze nog niet bestond.

Antwoord 25

Deze code zal uw behoefte verguld:

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

Antwoord 26

Als u wat tekst wilt toevoegen in specifieke regels U kunt eerst het hele bestand lezen, de tekst toevoegen waar u maar wilt en vervolgens alles wilt overschrijven zoals in de onderstaande 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();
    }
}

Antwoord 27

Mijn antwoord:

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
}

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

Antwoord 29

Voor JDK versie & gt; = 7

U kunt deze eenvoudige methode die de gegeven inhoud aan het opgegeven bestand voegt gebruiken:

void appendToFile(String filePath, String content) {
  try (FileWriter fw = new FileWriter(filePath, true)) {
    fw.write(content + System.lineSeparator());
  } catch (IOException e) { 
    // TODO handle exception
  }
}

We zijn de bouw van een FileWriter object in uitbreidingsmodus.

ANTWOORD 30

U kunt de Follong code gebruiken om de inhoud in het bestand toevoegen:

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