Cara menambahkan teks ke file yang ada di Jawa

Saya perlu menambahkan teks berulang kali ke file yang ada di Jawa. Bagaimana aku melakukan itu?

Apakah Anda melakukan ini untuk tujuan logging? Jika demikian ada beberapa perpustakaan untuk ini . Dua yang paling populer adalah Log4j dan Logback .

Java 7+

Jika Anda hanya perlu melakukan ini satu kali saja, kelas Files membuatnya mudah:

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

^{Hati-hati : Pendekatan di atas akan melempar NoSuchFileExceptionjika file belum ada. Itu juga tidak menambahkan baris baru secara otomatis (yang sering Anda inginkan ketika menambahkan file teks). Jawaban Steve Chambers mencakup bagaimana Anda dapat melakukan ini dengan Fileskelas.}

Namun, jika Anda akan menulis ke file yang sama berkali-kali, hal di atas harus membuka dan menutup file pada disk berkali-kali, yang merupakan operasi lambat. Dalam hal ini, penulis buffered lebih baik:

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
}

Catatan:

• Parameter kedua ke FileWriterkonstruktor akan memberitahu itu untuk menambahkan ke file, daripada menulis file baru. (Jika file tidak ada, itu akan dibuat.)
• Menggunakan sebuah BufferedWriter dianjurkan untuk seorang penulis mahal (seperti FileWriter).
• Menggunakan PrintWritermemberi Anda akses ke printlnsintaksis yang mungkin Anda gunakanSystem.out .
• Namun bungkus BufferedWriterdan PrintWritertidak sepenuhnya diperlukan.

Jawa yang lebih tua

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
}

Penanganan Eksepsi

Jika Anda membutuhkan penanganan pengecualian yang kuat untuk Java yang lebih lama, itu menjadi sangat verbose:

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

Anda dapat menggunakan fileWriterdengan set bendera ke true, untuk menambahkan.

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

Tidakkah seharusnya semua jawaban di sini dengan blok coba / tangkap memiliki potongan .close () yang ada pada blok akhirnya?

Contoh untuk jawaban yang ditandai:

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

Selain itu, pada Java 7, Anda dapat menggunakan pernyataan coba-dengan-sumber daya . Akhirnya tidak diperlukan blokir untuk menutup sumber daya yang dideklarasikan karena ditangani secara otomatis, dan juga kurang bertele-tele:

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

Edit - pada Apache Commons 2.1, cara yang benar untuk melakukannya adalah:

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

Saya mengadaptasi solusi @ Kip untuk menyertakan penutupan file dengan benar pada akhirnya:

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

Untuk sedikit memperluas jawaban Kip , berikut adalah metode Java 7+ sederhana untuk menambahkan baris baru ke file, membuatnya jika belum ada :

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

Catatan: Di atas menggunakan Files.writekelebihan yang menulis baris teks ke file (yaitu mirip dengan printlnperintah). Untuk hanya menulis teks sampai akhir (yaitu mirip dengan printperintah), Files.writeoverload alternatif dapat digunakan, lewat dalam array byte (misalnya "mytext".getBytes(StandardCharsets.UTF_8)).

Pastikan aliran ditutup dengan benar di semua skenario.

Agak mengkhawatirkan berapa banyak dari jawaban ini yang membiarkan file terbuka jika terjadi kesalahan. Jawabannya https://stackoverflow.com/a/15053443/2498188 ada pada uang tetapi hanya karena BufferedWriter()tidak bisa melempar. Jika bisa maka pengecualian akan membiarkan FileWriterobjek terbuka.

Cara yang lebih umum untuk melakukan ini yang tidak peduli jika BufferedWriter()bisa melempar:

  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:

Pada Java 7, cara yang disarankan adalah menggunakan "coba dengan sumber daya" dan biarkan JVM menghadapinya:

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

Di Java-7 juga bisa dilakukan seperti:

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

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

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

java 7+

Menurut pendapat saya yang rendah hati karena saya penggemar java polos, saya akan menyarankan sesuatu yang merupakan kombinasi dari jawaban yang disebutkan di atas. Mungkin saya terlambat ke pesta. Ini kodenya:

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

Jika file tidak ada, itu membuatnya dan jika sudah ada itu menambahkan sampleText ke file yang ada. Dengan menggunakan ini, Anda tidak perlu menambahkan lib yang tidak perlu ke classpath Anda.

Ini dapat dilakukan dalam satu baris kode. Semoga ini membantu :)

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

Menggunakan java.nio. File bersama dengan 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();

Ini menciptakan BufferedWriterFiles menggunakan, yang menerima StandardOpenOptionparameter, dan auto-flushing PrintWriterdari resultan BufferedWriter. PrintWriter's println()metode, kemudian dapat dipanggil untuk menulis ke file.

The StandardOpenOptionparameter yang digunakan dalam kode ini: membuka file untuk menulis, hanya menambahkan ke file, dan menciptakan file jika itu tidak ada.

Paths.get("path here")dapat diganti dengan new File("path here").toPath(). Dan Charset.forName("charset name")dapat dimodifikasi untuk mengakomodasi yang diinginkan Charset.

Saya hanya menambahkan detail kecil:

    new FileWriter("outfilename", true)

Parameter 2.nd (true) adalah fitur (atau, antarmuka) yang disebut appendable ( http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html ). Ini bertanggung jawab untuk dapat menambahkan beberapa konten ke akhir file / stream tertentu. Antarmuka ini diimplementasikan sejak Java 1.5. Setiap objek (yaitu BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer ) dengan antarmuka ini dapat digunakan untuk menambahkan konten

Dengan kata lain, Anda dapat menambahkan beberapa konten ke file gzipped Anda, atau beberapa proses http

Contoh, menggunakan Jambu Biji:

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

Coba dengan bufferFileWriter.append, ini berfungsi dengan saya.

FileWriter fileWriter;
try {
    fileWriter = new FileWriter(file,true);
    BufferedWriter bufferFileWriter = new BufferedWriter(fileWriter);
    bufferFileWriter.append(obj.toJSONString());
    bufferFileWriter.newLine();
    bufferFileWriter.close();
} catch (IOException ex) {
    Logger.getLogger(JsonTest.class.getName()).log(Level.SEVERE, null, ex);
}

    String str;
    String path = "C:/Users/...the path..../iin.txt"; // you can input also..i created this way :P

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw = new PrintWriter(new FileWriter(path, true));

    try 
    {
       while(true)
        {
            System.out.println("Enter the text : ");
            str = br.readLine();
            if(str.equalsIgnoreCase("exit"))
                break;
            else
                pw.println(str);
        }
    } 
    catch (Exception e) 
    {
        //oh noes!
    }
    finally
    {
        pw.close();         
    }

ini akan melakukan apa yang Anda inginkan ..

Lebih baik menggunakan try-with-resources daripada semua yang pra-java 7 akhirnya bisnis

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

Jika kita menggunakan Java 7 dan di atasnya dan juga tahu konten yang akan ditambahkan (ditambahkan) ke file kita dapat menggunakan metode newBufferedWriter dalam paket 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();
    }
}

Ada beberapa hal yang perlu diperhatikan:

1. Itu selalu merupakan kebiasaan yang baik untuk menentukan pengkodean charset dan untuk itu kita memiliki konstanta di kelas StandardCharsets.
2. Kode menggunakan try-with-resourcepernyataan di mana sumber daya secara otomatis ditutup setelah percobaan.

Meskipun OP belum bertanya tetapi untuk berjaga-jaga jika kita ingin mencari baris yang memiliki beberapa kata kunci spesifik misalnya confidentialkita dapat menggunakan stream API di Jawa:

//Reading from the file the first line which contains word "confidential"
try {
    Stream<String> lines = Files.lines(FILE_PATH);
    Optional<String> containsJava = lines.filter(l->l.contains("confidential")).findFirst();
    if(containsJava.isPresent()){
        System.out.println(containsJava.get());
    }
} catch (IOException e) {
    e.printStackTrace();
}

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

yang sebenarnya memungkinkan untuk menambahkan data dalam file yang ada. Jika kita akan menulis

FileOutputStream fos = new FileOutputStream("File_Name");

Ini akan menimpa file yang ada. Jadi lakukan pendekatan pertama.

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

public class Writer {


    public static void main(String args[]){
        doWrite("output.txt","Content to be appended to file");
    }

    public static void doWrite(String filePath,String contentToBeAppended){

       try(
            FileWriter fw = new FileWriter(filePath, true);
            BufferedWriter bw = new BufferedWriter(fw);
            PrintWriter out = new PrintWriter(bw)
          )
          {
            out.println(contentToBeAppended);
          }  
        catch( IOException e ){
        // File writing/opening failed at some stage.
        }

    }

}

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

    stream.write(

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

    );

} finally {
    stream.close();
}

Kemudian tangkap IOException di suatu tempat di hulu.

Buat fungsi di mana saja di proyek Anda dan cukup panggil fungsi itu di mana pun Anda membutuhkannya.

Kalian harus ingat bahwa kalian memanggil utas aktif yang tidak kamu panggil secara tidak sinkron dan karena itu mungkin merupakan 5 sampai 10 halaman yang baik untuk menyelesaikannya dengan benar. Mengapa tidak menghabiskan lebih banyak waktu untuk proyek Anda dan lupakan menulis apa pun yang sudah ditulis. Tepat

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

tiga baris kode dua benar-benar sejak yang ketiga benar-benar menambahkan teks. : P

Perpustakaan

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

Kode

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

Anda juga dapat mencoba ini:

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
}

Saya mungkin menyarankan proyek apache commons . Proyek ini sudah menyediakan kerangka kerja untuk melakukan apa yang Anda butuhkan (yaitu penyaringan koleksi yang fleksibel).

Metode berikut memungkinkan Anda menambahkan teks ke beberapa 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();
        }
    }
}

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

Ini tidak efisien tetapi berfungsi dengan baik. Jeda baris ditangani dengan benar dan file baru dibuat jika belum ada.

Kode ini akan memenuhi kebutuhan Anda:

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

Jika Anda ingin MENAMBAH BEBERAPA TEKS DALAM JARINGAN KHUSUS, Anda dapat membaca seluruh file terlebih dahulu, menambahkan teks di mana pun Anda inginkan dan kemudian menimpa semuanya seperti dalam kode di bawah ini:

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

Jawabanku:

JFileChooser chooser= new JFileChooser();
chooser.showOpenDialog(chooser);
File file = chooser.getSelectedFile();
String Content = "What you want to append to file";

try 
{
    RandomAccessFile random = new RandomAccessFile(file, "rw");
    long length = random.length();
    random.setLength(length + 1);
    random.seek(random.length());
    random.writeBytes(Content);
    random.close();
} 
catch (Exception exception) {
    //exception handling
}

/**********************************************************************
 * it will write content to a specified  file
 * 
 * @param keyString
 * @throws IOException
 *********************************************************************/
public static void writeToFile(String keyString,String textFilePAth) throws IOException {
    // For output to file
    File a = new File(textFilePAth);

    if (!a.exists()) {
        a.createNewFile();
    }
    FileWriter fw = new FileWriter(a.getAbsoluteFile(), true);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.append(keyString);
    bw.newLine();
    bw.close();
}// end of writeToFile()

Anda dapat menggunakan kode follong untuk menambahkan konten dalam 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.7 Pendekatan:

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