Как добавить текст в существующий файл в Java

можно использовать fileWriter с флагом true , для присоединения.

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

Не Должны ли все ответы здесь с блоками try /catch иметь.закрыть () части, содержащиеся в блоке finally?

пример для отмеченного ответа:

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

кроме того, начиная с Java 7, Вы можете использовать try-with-resources заявление. Никакой блок finally не требуется для закрытия объявленных ресурсов, потому что он обрабатывается автоматически, а также менее подробен:

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

Edit - по состоянию на Apache Commons 2.1, правильный способ сделать это:

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

я адаптировал решение @Kip, чтобы включить правильное закрытие файла на finally:

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

убедитесь, что поток правильно закрывается во всех сценариях.

это немного тревожно, сколько из этих ответов оставить дескриптор файла открытым в случае ошибки. Ответ https://stackoverflow.com/a/15053443/2498188 стоит на деньгах но только потому что BufferedWriter() не может бросить. Если бы это было возможно, то исключение оставило бы FileWriter открыть объект.

более общий способ сделать это, не волнует, если BufferedWriter() может бросок:

  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:

начиная с Java 7, рекомендуется использовать "try with resources" и позволить JVM справиться с этим:

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

чтобы немного расширить Кип, вот простой метод Java 7+ для добавления a новая строка в файл создание его, если он еще не существует:

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

Примечание: выше используется Files.write перегрузка, которая пишет строки текста в файл (т. е. аналогично ). Чтобы просто написать текст до конца (т. е. похож на print command), альтернатива Files.write перегрузку можно использовать, передавая в массив байтов (например "mytext".getBytes(StandardCharsets.UTF_8)).

в Java-7 это же можно сделать такого вида:

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

образец, используя 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);
}

Это можно сделать в одной строке кода. Надеюсь, это поможет :)

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

java 7+

по моему скромному мнению, поскольку я поклонник простой java, я бы предложил что-то, что это комбинация вышеупомянутых ответов. Может быть, я опаздываю на вечеринку. Вот код:

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

если файл не существует, он создает его, а если уже существует, он добавляет sampleText к существующему файлу. Используя это, вы избавляетесь от добавления ненужных библиотек в свой путь к классам.

Я просто добавляю небольшую деталь:

    new FileWriter("outfilename", true)

2.параметр nd (true) - это функция (или интерфейс) с именем дозаписываемый диск (http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html). он отвечает за возможность добавления некоторого контента в конец конкретного файла/потока. Этот интерфейс реализован начиная с Java 1.5. Каждый объект (т. е. BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer) С помощью этого интерфейса можно использовать для добавления контента

другими словами, вы можете добавить некоторый контент в свой gzipped-файл или некоторый http-процесс

использование java.НИО.файлы вместе с java.НИО.файл.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();

это создает BufferedWriter использование файлов, которые принимают StandardOpenOption параметры и автоматическая промывка PrintWriter от равнодействующей BufferedWriter. PrintWriter ' s println() метод, затем может быть вызван для записи в файл.

The StandardOpenOption параметры, используемые в этом коде: открывает файл для записи, только добавляет к файлу и создает файл, если это не так существовать.

Paths.get("path here") можно заменить на new File("path here").toPath(). И Charset.forName("charset name") может быть изменен для размещения желаемого Charset.

попробуйте с bufferFileWriter.добавь, это работает со мной.

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

это будет делать то, что вы собираетесь для..

если мы используем Java 7 и выше, а также знаем содержимое, которое будет добавлено (добавлено) в файл, мы можем использовать newBufferedWriter метод в пакете 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();
    }
}

есть несколько моментов, чтобы отметить:

1. это всегда хорошая привычка, чтобы указать кодировку кодировки и для этого у нас есть константа в классе StandardCharsets.
2. код использует try-with-resource оператор, в котором ресурсы автоматически закрываются после пытаться.

хотя OP не спрашивал, но на всякий случай мы хотим искать строки, имеющие какое-то конкретное ключевое слово, например confidential мы можем использовать потоковые API в 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();
}

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

    stream.write(

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

    );

} finally {
    stream.close();
}

затем поймать IOException где-то выше по течению.

создайте функцию в любом месте вашего проекта и просто вызовите эту функцию там, где вам это нужно.

Ребята, вы должны помнить, что вы, ребята, вызываете активные потоки, которые вы не вызываете асинхронно, и поскольку это, вероятно, будет хорошим от 5 до 10 страниц, чтобы сделать это правильно. Почему бы не потратить больше времени на свой проект и забыть о написании чего уже написано. Правильно

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

три строки кода два действительно, так как третий фактически добавляет текст. : P

библиотека

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

код

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

вы также можете попробовать это:

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
}

лучше использовать try-with-resources, то все, что до java 7, наконец, бизнес

static void appendStringToFile(Path file, String s) throws IOException  {
    try (BufferedWriter out = Files.newBufferedWriter(file, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        out.append(s);
        out.newLine();
    }
}

этот код будет выполнять ваши потребности:

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

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

true позволяет добавлять данные в существующий файл. Если напишем

FileOutputStream fos = new FileOutputStream("File_Name");

Он перезапишет существующий файл. Так что идите на первый подход.

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

    }

}

Я мог бы предложить проект Apache commons. Этот проект уже предоставляет основу для выполнения того, что вам нужно (т. е. гибкую фильтрацию коллекций).

следующий метод давайте вы добавляете текст в какой-то файл:

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

С помощью 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);
}

это не эффективно, но работает нормально. Разрывы строк обрабатываются правильно и создается новый файл, если он еще не существует.

мой ответ:

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
}

в случае, если вы хотите ДОБАВИТЬ ТЕКСТ В ОПРЕДЕЛЕННЫХ СТРОКАХ вы можете сначала прочитать весь файл, добавить текст, где вы хотите, а затем переписать все как в код ниже:

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

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

вы можете использовать код follong для добавления содержимого в файл:

 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 подхода:

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