Come aggiungere testo a un file esistente in Java


Risposte:


793

Lo stai facendo a scopo di registrazione? In tal caso, esistono diverse librerie per questo . Due dei più popolari sono Log4j e Logback .

Java 7+

Se hai solo bisogno di farlo una volta, la classe Files lo rende facile:

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

Attenzione : l'approccio sopra genererà un NoSuchFileExceptionse il file non esiste già. Inoltre non aggiunge automaticamente una nuova riga (che spesso si desidera quando si aggiunge a un file di testo). La risposta di Steve Chambers riguarda come puoi farlo con la Filesclasse.

Tuttavia, se si scriverà sullo stesso file più volte, quanto sopra deve aprire e chiudere il file sul disco molte volte, il che è un'operazione lenta. In questo caso, uno scrittore con buffer è migliore:

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
}

Appunti:

  • Il secondo parametro al FileWritercostruttore dirà di aggiungere al file, piuttosto che scrivere un nuovo file. (Se il file non esiste, verrà creato.)
  • Usando una BufferedWriterè raccomandato per uno scrittore costoso (come ad esempio FileWriter).
  • L'uso di a PrintWriterti dà accesso alla printlnsintassi a cui probabilmente sei abituato System.out.
  • Ma i wrapper BufferedWritere PrintWriternon sono strettamente necessari.

Java precedente

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
}

La gestione delle eccezioni

Se hai bisogno di una solida gestione delle eccezioni per Java precedente, diventa molto dettagliato:

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

31
Dovresti usare java7 try-with-resources o mettere close () in un blocco finally, per assicurarti che il file sia chiuso in caso di eccezione
Svetlin Zarev

1
aggiornato con la sintassi Java 7. la gestione delle eccezioni è ancora lasciata come esercizio per il lettore, ma ha reso il commento più chiaro.
Kip

3
Immaginiamo che new BufferedWriter(...)genera un'eccezione; Sarà FileWriterchiuso? Immagino che non verrà chiuso, perché il close()metodo (in condizioni normali) verrà invocato outsull'oggetto, che in questo caso non verrà inizializzato - quindi in realtà il close()metodo non verrà invocato -> il file verrà aperto, ma non sarà chiuso. Quindi IMHO la trydichiarazione dovrebbe assomigliare a questo try(FileWriter fw = new FileWriter("myFile.txt")){ Print writer = new ....//code goes here } E dovrebbe flush()lo scrittore prima di uscire dal tryblocco !!!
Svetlin Zarev,

5
Attenzione, l'esempio "Older java" non chiuderà correttamente il flusso se viene generata un'eccezione all'interno del blocco try.
Emily L.,

1
Un paio di possibili "gotchas" con il metodo Java 7: (1) Se il file non esiste già, StandardOpenOption.APPENDnon lo creerà - un po 'come un errore silenzioso in quanto non genererà nemmeno un'eccezione. (2) L'uso .getBytes()significa che non è presente alcun carattere di ritorno prima o dopo il testo allegato. Ho aggiunto una risposta alternativa per affrontarli.
Steve Chambers,

166

È possibile utilizzare fileWritercon un flag impostato su true, per aggiungere.

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

9
closedovrebbe essere posto in finallyblocco proprio come mostrato nella risposta di @ etech nel caso in cui si generasse un'eccezione tra la creazione di FileWriter e il richiamo della chiusura.
Pshemo,

5
Buona risposta, anche se è meglio usare System.getProperty ("line.separator") per una nuova riga anziché "\ n".
Henry Zhu,

@ Decodificato Ho eseguito il rollback della modifica su questa risposta, poiché non viene compilata.
Kip

@Kip, qual era il problema? Devo aver inserito un "refuso".
Decodificato il

2
Che ne dici di provare con le risorse? try(FileWriter fw = new FileWriter(filename,true)){ // Whatever }catch(IOException ex){ ex.printStackTrace(); }
php_coder_3809625,

72

Tutte le risposte qui con i blocchi try / catch non dovrebbero contenere i pezzi .close () contenuti in un blocco finally?

Esempio di risposta contrassegnata:

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

Inoltre, a partire da Java 7, è possibile utilizzare un'istruzione try-with-resources . Nessun blocco infine è richiesto per chiudere le risorse dichiarate perché viene gestito automaticamente ed è anche meno dettagliato:

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

1
Quando outesce dal campo di applicazione, si chiude automaticamente quando viene raccolta spazzatura, giusto? Nel tuo esempio con il finallyblocco, penso che tu abbia effettivamente bisogno di un altro tentativo nidificato out.close()se ricordo bene. La soluzione Java 7 è piuttosto elegante! (Non sto facendo alcun sviluppatore Java da Java 6, quindi non avevo familiarità con quel cambiamento.)
Kip

1
@Kip No, uscire dall'ambito non fa nulla in Java. Il file verrà chiuso in un momento casuale in futuro. (probabilmente alla chiusura del programma)
Navin,

@etech Il secondo approccio avrà bisogno del flushmetodo?
syfantid,

43

Modifica - a partire da Apache Commons 2.1, il modo corretto per farlo è:

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

Ho adattato la soluzione di @ Kip per includere finalmente la chiusura corretta del file:

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


5
Oh grazie. Sono stato divertito dalla complessità di tutte le altre risposte. Davvero non capisco perché alla gente piaccia complicare la vita (degli sviluppatori).
Alphaaa,

Il problema con questo approccio è che apre e chiude il flusso di output ogni volta. A seconda di cosa e quanto spesso scrivi sul tuo file, questo potrebbe comportare un sovraccarico ridicolo.
Buffalo,

@Buffalo ha ragione. Ma puoi sempre usare StringBuilder per costruire grossi pezzi (che vale la pena scrivere) prima di scriverli su file.
Konstantin K,

32

Per espandere leggermente la risposta di Kip , ecco un semplice metodo Java 7+ per aggiungere una nuova riga a un file, creandolo se non esiste già :

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

Nota: quanto sopra utilizza il Files.writesovraccarico che scrive righe di testo in un file (cioè simile a un printlncomando). Per scrivere solo un testo alla fine (cioè simile a un printcomando), è Files.writepossibile utilizzare un sovraccarico alternativo , passando in un array di byte (ad es "mytext".getBytes(StandardCharsets.UTF_8).).


Devi verificare se il file esiste? Ho pensato che .CREATEfa il lavoro per te.
LearningToJava

22

Assicurati che il flusso venga chiuso correttamente in tutti gli scenari.

È un po 'allarmante quante di queste risposte lasciano aperto l'handle del file in caso di errore. La risposta https://stackoverflow.com/a/15053443/2498188 è sui soldi, ma solo perché BufferedWriter()non può lanciare. Se fosse possibile, un'eccezione lascerebbe l' FileWriteroggetto aperto.

Un modo più generale di fare questo a cui non importa se BufferedWriter()può lanciare:

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

Modificare:

A partire da Java 7, il modo consigliato è utilizzare "prova con risorse" e lasciare che JVM lo gestisca:

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

+1 per ARM corretto con Java 7. Ecco una buona domanda su questo tema complicato: stackoverflow.com/questions/12552863/… .
Vadzim,

1
Hmm, per qualche motivo PrintWriter.close()non è dichiarato come throws IOExceptionnei documenti . Guardando alla sua fonte , il close()metodo, infatti, non può essere lanciato IOException, perché lo cattura dal flusso sottostante e imposta una bandiera. Quindi, se stai lavorando sul codice per il prossimo Space Shuttle o un sistema di misurazione della dose di raggi X, dovresti usarlo PrintWriter.checkError()dopo aver provato a farlo out.close(). Questo avrebbe dovuto essere documentato.
Evgeni Sergeev,

Se saremo super paranoici riguardo alla chiusura, ognuno di questi XX.close()dovrebbe essere nel suo tentativo / cattura, giusto? Ad esempio, out.close()potrebbe generare un'eccezione, nel qual caso bw.close()e fw.close()non verrebbe mai chiamato, ed fwè quello più critico da chiudere.
Kip

13

In Java-7 si può fare anche questo tipo:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

// ---------------------

Path filePath = Paths.get("someFile.txt");
if (!Files.exists(filePath)) {
    Files.createFile(filePath);
}
Files.write(filePath, "Text to be added".getBytes(), StandardOpenOption.APPEND);

2
Quali sono le importazioni richieste? Quale biblioteca usano queste cose?
Chetan Bhasin,

9

java 7+

Secondo la mia modesta opinione, dato che sono fan della pianura Java, suggerirei che si tratta di una combinazione delle risposte di cui sopra. Forse sono in ritardo per la festa. Ecco il codice:

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

Se il file non esiste, lo crea e, se esiste già, aggiunge sampleText al file esistente. Usando questo, ti salva dall'aggiunta di lib libere al tuo percorso di classe.


8

Questo può essere fatto in una riga di codice. Spero che sia di aiuto :)

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

1
potrebbe non essere sufficiente :) la versione migliore è Files.write (Paths.get (fileName), msg.getBytes (), StandardOpenOption.APPEND, StandardOpenOption.CREATE);
evg345,

6

Utilizzando java.nio. File insieme a 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();

Ciò crea un BufferedWriterfile di utilizzo, che accetta i StandardOpenOptionparametri e uno svuotamento automatico PrintWriterdal risultante BufferedWriter. PrintWriter's println()metodo, può quindi essere chiamato a scrittura al file.

I StandardOpenOptionparametri utilizzati in questo codice: apre il file per la scrittura, aggiunge solo il file e crea il file se non esiste.

Paths.get("path here")può essere sostituito con new File("path here").toPath(). E Charset.forName("charset name")può essere modificato per accogliere il desiderato Charset.


5

Aggiungo solo piccoli dettagli:

    new FileWriter("outfilename", true)

2.nd parametro (true) è una funzione (o interfaccia) chiamata appendable ( http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html ). È responsabile della possibilità di aggiungere del contenuto alla fine di un determinato file / flusso. Questa interfaccia è implementata da Java 1.5. Ogni oggetto (ad es. BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer ) può essere utilizzato per aggiungere contenuto

In altre parole, puoi aggiungere del contenuto al tuo file gzipped o un processo http


4

Esempio, usando 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);
}

13
Questo è un consiglio orribile. Si apre uno stream sul file 42 volte anziché una volta.
xehpuk,

3
@xehpuk bene, dipende. 42 è ancora ok, se rende il codice molto più leggibile. 42k non sarebbero accettabili.
Dantuch,

4

Prova con bufferFileWriter.append, funziona con me.

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

che cosa è obj.toJSONString () qui?
Bhaskara Arani,

@BhaskaraArani È solo una stringa, ha messo un esempio di un oggetto JSON convertito in una stringa ma l'idea è che potrebbe essere qualsiasi stringa.
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();         
    }

questo farà ciò che intendi per ..


3

Meglio usare try-with-resources, quindi tutte quelle pre-java 7 finalmente disponibili

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

3

Se stiamo utilizzando Java 7 e versioni successive e conosciamo anche il contenuto da aggiungere (aggiunto) al file, possiamo utilizzare il metodo newBufferedWriter nel pacchetto NIO.

public static void main(String[] args) {
    Path FILE_PATH = Paths.get("C:/temp", "temp.txt");
    String text = "\n Welcome to Java 8";

    //Writing to the file temp.txt
    try (BufferedWriter writer = Files.newBufferedWriter(FILE_PATH, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        writer.write(text);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ci sono alcuni punti da notare:

  1. È sempre una buona abitudine specificare la codifica del set di caratteri e per questo abbiamo una costante in classe StandardCharsets.
  2. Il codice utilizza try-with-resourceun'istruzione in cui le risorse vengono automaticamente chiuse dopo il tentativo.

Sebbene OP non l'abbia chiesto, ma nel caso in cui desideriamo cercare righe con una parola chiave specifica, ad esempio confidentialpossiamo utilizzare API di flusso 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();
}

un avvertimento: quando si utilizza BufferedWriter write(String string)se ci si aspetta una nuova riga dopo ogni stringa scritta, newLine()dovrebbe essere chiamato
yongtw123

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

il vero consente di aggiungere i dati nel file esistente. Se scriveremo

FileOutputStream fos = new FileOutputStream("File_Name");

Sovrascriverà il file esistente. Quindi vai per il primo approccio.


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

    }

}

Quanto sopra è solo un rapido esempio di implementazione della soluzione presentata a questo link . Quindi puoi copiare ed eseguire il codice e vedere immediatamente come funziona, assicurati che il file output.out sia nella stessa directory del file Writer.java
David Charles,

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

    stream.write(

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

    );

} finally {
    stream.close();
}

Quindi catturare una IOException da qualche parte a monte.


2

Crea una funzione ovunque nel tuo progetto e chiama semplicemente quella funzione ovunque tu ne abbia bisogno.

Ragazzi, dovrete ricordare che voi ragazzi state chiamando thread attivi che non state chiamando in modo asincrono e dal momento che sarebbe probabilmente un buon 5-10 pagine per farlo bene. Perché non dedicare più tempo al tuo progetto e dimenticare di scrivere qualcosa di già scritto. Propriamente

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

tre righe di codice due in realtà dal momento che il terzo aggiunge effettivamente il testo. : P


2

Biblioteca

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

Codice

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

2

Puoi anche provare questo:

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
}


1

Il seguente metodo consente di aggiungere del testo ad alcuni file:

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

In alternativa usando 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);
}

Non è efficiente ma funziona bene. Le interruzioni di riga vengono gestite correttamente e viene creato un nuovo file se non ne esiste ancora uno.



1

Nel caso in cui desideri AGGIUNGERE QUALSIASI TESTO IN LINEE SPECIFICHE puoi prima leggere l'intero file, aggiungere il testo dove vuoi e quindi sovrascrivere tutto come nel codice qui sotto:

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

0

La mia risposta:

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
}

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

-1

È possibile utilizzare il codice seguente per aggiungere il contenuto nel file:

 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

1.7 Approccio:

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);
    }*/
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.