Como anexar texto a um arquivo existente em Java


Respostas:


793

Você está fazendo isso para fins de registro? Nesse caso, existem várias bibliotecas para isso . Dois dos mais populares são o Log4j e o Logback .

Java 7 ou superior

Se você precisar fazer isso apenas uma vez, a classe Arquivos facilita isso:

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

Cuidado : A abordagem acima lançará um NoSuchFileExceptionse o arquivo ainda não existir. Ele também não anexa uma nova linha automaticamente (o que você geralmente deseja ao anexar a um arquivo de texto). A resposta de Steve Chambers cobre como você pode fazer isso com a Filesclasse.

No entanto, se você estiver gravando no mesmo arquivo várias vezes, o procedimento acima deverá abrir e fechar o arquivo no disco várias vezes, o que é uma operação lenta. Nesse caso, um gravador em buffer é melhor:

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
}

Notas:

  • O segundo parâmetro para o FileWriterconstrutor solicitará que ele seja anexado ao arquivo, em vez de gravar um novo arquivo. (Se o arquivo não existir, ele será criado.)
  • BufferedWriterÉ recomendável usar a para um gravador caro (como FileWriter).
  • Usar a PrintWriterfornece acesso à printlnsintaxe à qual você provavelmente está acostumado System.out.
  • Mas os invólucros BufferedWritere PrintWriternão são estritamente necessários.

Java mais antigo

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
}

Manipulação de exceção

Se você precisar de um tratamento robusto de exceções para Java antigo, ele ficará muito detalhado:

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
Você deve usar try-with-recursos Java7 ou colocar o close () no bloco finally, a fim de se certificar de que o arquivo é fechado em caso de exceção
Svetlin Zarev

1
atualizado com a sintaxe do Java 7. o tratamento de exceções ainda é deixado como um exercício para o leitor, mas tornou o comentário mais claro.
Kip

3
Vamos imaginar que isso new BufferedWriter(...)lança uma exceção; O FileWriterserá fechado? Eu acho que não será fechado, porque o close()método (em condições normais) será invocado no outobjeto, que neste caso não será inicializado - portanto, na verdade, o close()método não será invocado -> o arquivo será aberto, mas não será fechado. Então IMHO a trydeclaração deve ficar assim try(FileWriter fw = new FileWriter("myFile.txt")){ Print writer = new ....//code goes here } E ele deveria flush()o escritor antes de sair do trybloco !!!
Svetlin Zarev

5
Cuidado, o exemplo "Java mais antigo" não fechará o fluxo corretamente se uma exceção for lançada dentro do bloco try.
Emily L.

1
Algumas possíveis "dicas" com o método Java 7: (1) Se o arquivo ainda não existir, StandardOpenOption.APPENDnão será criado - como uma falha silenciosa, pois também não causará uma exceção. (2) Usar .getBytes()significa que não há caracteres de retorno antes ou depois do texto anexado. Adicionaram uma resposta alternativa para resolvê-las.
Steve Chambers

166

Você pode usar fileWritercom um sinalizador definido como true, para anexar.

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
closedeve ser colocado no finallybloco, como mostrado na resposta do @ etech, caso exista uma exceção entre a criação do FileWriter e a chamada close.
Pshemo

5
Boa resposta, embora seja melhor usar System.getProperty ("line.separator") para uma nova linha em vez de "\ n".
Henry Zhu

@ Decodificado Retornamos sua edição nesta resposta, pois ela não é compilada.
Kip

@ Kip, qual foi o problema? Eu devo ter digitado um "erro de digitação".
Decodificado

2
Que tal tentar com recursos? try(FileWriter fw = new FileWriter(filename,true)){ // Whatever }catch(IOException ex){ ex.printStackTrace(); }
Php_coder_3809625

72

Todas as respostas aqui dos blocos try / catch não deveriam ter as partes .close () contidas em um bloco finalmente?

Exemplo para resposta marcada:

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

Além disso, a partir do Java 7, você pode usar uma instrução try-with-resources . Finalmente, nenhum bloco é necessário para fechar o (s) recurso (s) declarado (s) porque ele é tratado automaticamente e também é menos detalhado:

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

1
Quando outsai do escopo, é automaticamente fechado quando é coletado do lixo, certo? No seu exemplo com o finallybloco, acho que você realmente precisa de outra tentativa / captura aninhada, out.close()se bem me lembro. A solução Java 7 é muito boa! (Eu não venho desenvolvendo Java desde o Java 6, então não estava familiarizado com essa alteração.) #
211 Kip de Kip

1
@ Kip Não, sair do escopo não faz nada em Java. O arquivo será fechado em algum momento aleatório no futuro. (provavelmente quando o programa fecha)
Navin

@etech A segunda abordagem precisará do flushmétodo?
syfantid

43

Editar - a partir do Apache Commons 2.1, a maneira correta de fazer isso é:

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

Adaptei a solução do @ Kip para incluir o fechamento correto do arquivo e finalmente:

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


4
Oh obrigada. Fiquei divertido com a complexidade de todas as outras respostas. Eu realmente não entendo por que as pessoas gostam de complicar sua vida (de desenvolvedor).
Alphaaa 29/07

O problema com essa abordagem é que ela abre e fecha o fluxo de saída todas as vezes. Dependendo do que e com que frequência você escreve no arquivo, isso pode resultar em uma sobrecarga ridícula.
Buffalo

@Buffalo está certo. Mas você sempre pode usar o StringBuilder para criar blocos grandes (que valem a pena ser gravados) antes de gravá-los no arquivo.
Konstantin K

32

Para expandir um pouco a resposta de Kip , aqui está um método Java 7+ simples para acrescentar uma nova linha a um arquivo, criando-o se ele ainda não existir :

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: A descrição acima usa a Files.writesobrecarga que grava linhas de texto em um arquivo (ou seja, semelhante a um printlncomando). Para escrever apenas texto no final (ou seja, semelhante a um printcomando), uma Files.writesobrecarga alternativa pode ser usada, passando em uma matriz de bytes (por exemplo "mytext".getBytes(StandardCharsets.UTF_8)).


Você precisa verificar se o arquivo existe? Eu pensei que .CREATEfaz o trabalho para você.
LearningToJava

22

Verifique se o fluxo é fechado corretamente em todos os cenários.

É um pouco alarmante quantas dessas respostas deixam o identificador de arquivo aberto em caso de erro. A resposta https://stackoverflow.com/a/15053443/2498188 está no dinheiro, mas apenas porque BufferedWriter()não pode ser lançada. Se pudesse, uma exceção deixaria o FileWriterobjeto aberto.

Uma maneira mais geral de fazer isso que não se importa se BufferedWriter()pode lançar:

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

Editar:

No Java 7, a maneira recomendada é usar "try with resources" e deixar a JVM lidar com isso:

  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 para o ARM correto com Java 7. Aqui está uma boa pergunta sobre este tema complicado: stackoverflow.com/questions/12552863/… .
Vadzim

1
Hmm, por algum motivo PrintWriter.close()não é declarado como throws IOExceptionnos documentos . Olhando para sua fonte , o close()método, de fato, não pode ser lançado IOException, porque o captura no fluxo subjacente e define uma sinalização. Portanto, se você estiver trabalhando no código para o próximo ônibus espacial ou em um sistema de medição de dose de raios-X, use-o PrintWriter.checkError()após tentar out.close(). Isso realmente deveria ter sido documentado.
Evgeni Sergeev

Se formos super paranóicos sobre o fechamento, cada um deles XX.close()deve estar em sua própria tentativa / captura, certo? Por exemplo, out.close()poderia lançar uma exceção, caso em que bw.close()e fw.close()nunca seria chamado, e fwé aquele que é mais crítico para perto.
Kip

13

No Java-7, isso também pode ser feito:

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
Quais são as importações necessárias? Qual biblioteca essas coisas usam?
Chetan Bhasin

9

java 7+

Na minha humilde opinião, já que sou fã de Java simples, sugiro algo que é uma combinação das respostas acima mencionadas. Talvez eu esteja atrasado para a festa. Aqui está o código:

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

Se o arquivo não existir, ele será criado e, se já existir, anexará o sampleText ao arquivo existente. Com isso, você evita adicionar bibliotecas desnecessárias ao seu caminho de classe.


8

Isso pode ser feito em uma linha de código. Espero que isto ajude :)

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

1
pode não ser suficiente :) a melhor versão é Files.write (Paths.get (fileName), msg.getBytes (), StandardOpenOption.APPEND, StandardOpenOption.CREATE);
Evg345

6

Usando java.nio. Arquivos junto com 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();

Isso cria um BufferedWriterarquivo usando, que aceita StandardOpenOptionparâmetros, e uma liberação automática PrintWriterdo resultante BufferedWriter. PrintWriterdo println()método, pode ser chamado para gravar no arquivo.

Os StandardOpenOptionparâmetros usados ​​neste código: abre o arquivo para gravação, anexa somente ao arquivo e cria o arquivo se ele não existir.

Paths.get("path here")pode ser substituído por new File("path here").toPath(). E Charset.forName("charset name")pode ser modificado para acomodar o desejado Charset.


5

Eu apenas adiciono pequenos detalhes:

    new FileWriter("outfilename", true)

2.nd parâmetro (true) é um recurso (ou interface) chamado appendable ( http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html ). É responsável por poder adicionar algum conteúdo ao final de um arquivo / fluxo específico. Essa interface é implementada desde o Java 1.5. Cada objeto (por exemplo , BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer ) com essa interface pode ser usado para adicionar conteúdo

Em outras palavras, você pode adicionar algum conteúdo ao seu arquivo compactado com gzip ou algum processo http


4

Amostra, usando o Goiaba:

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
Este é um conselho horrível. Você abre um fluxo no arquivo 42 vezes em vez de uma vez.
xehpuk

3
@xehpuk bem, depende. 42 ainda está ok, se tornar o código muito mais legível. 42k não seria aceitável.
dantuch

4

Tente com bufferFileWriter.append, ele funciona comigo.

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

o que é obj.toJSONString () aqui?
Bhaskara Arani

@BhaskaraArani É apenas uma string, ele colocou um exemplo de um objeto JSON convertido em uma string, mas a idéia é que poderia ser qualquer string.
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();         
    }

isso fará o que você pretende ..


3

Melhor usar o try-with-resources do que todos os negócios pré-java 7 finalmente

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 estivermos usando o Java 7 e superior e também soubermos o conteúdo a ser adicionado (anexado) ao arquivo, podemos usar o método newBufferedWriter no pacote 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();
    }
}

Há alguns pontos a serem observados:

  1. É sempre um bom hábito especificar a codificação de charset e, para isso, temos constantes em classe StandardCharsets.
  2. O código usa a try-with-resourceinstrução na qual os recursos são fechados automaticamente após a tentativa.

Embora o OP não tenha perguntado, apenas no caso de querermos procurar linhas com alguma palavra-chave específica, por exemplo confidential, podemos usar APIs de fluxo em 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();
}

uma ressalva: quando se utiliza BufferedWriter write(String string)Se alguém espera uma nova linha após cada corda escrita, newLine()deve ser chamado
yongtw123

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

o true permite acrescentar os dados no arquivo existente. Se vamos escrever

FileOutputStream fos = new FileOutputStream("File_Name");

Ele substituirá o arquivo existente. Então vá para a primeira abordagem.


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

    }

}

O acima é apenas um exemplo rápido de implementação da solução apresentada neste link . Então você pode copiar e e executar o código e ver imediatamente como ele funciona, certifique-se de que o arquivo output.out está no mesmo diretório que o arquivo Writer.java
David Charles

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

    stream.write(

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

    );

} finally {
    stream.close();
}

Em seguida, pegue uma IOException em algum lugar a montante.


2

Crie uma função em qualquer lugar do seu projeto e simplesmente chame essa função sempre que precisar.

Gente, você deve se lembrar de que está chamando threads ativos que não está chamando de forma assíncrona e, uma vez que provavelmente seriam boas 5 a 10 páginas para fazê-lo corretamente. Por que não dedicar mais tempo ao seu projeto e esquecer de escrever qualquer coisa que já esteja escrita? Devidamente

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

três linhas de código dois, na verdade, uma vez que a terceira acrescenta texto. : P


2

Biblioteca

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

Código

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

Você também pode tentar o seguinte:

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

O método a seguir permite anexar texto a algum arquivo:

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

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

Não é eficiente, mas funciona bem. Quebras de linha são tratadas corretamente e um novo arquivo é criado se ainda não existir.



1

Caso você queira ADICIONAR ALGUM TEXTO EM LINHAS ESPECÍFICAS, primeiro você pode ler o arquivo inteiro, anexar o texto onde quiser e substituir tudo como no código abaixo:

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

Minha resposta:

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

Você pode usar o código a seguir para anexar o conteúdo no arquivo:

 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 Abordagem:

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);
    }*/
}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.