Como faço para salvar uma String em um arquivo de texto usando Java?

Em Java, tenho texto de um campo de texto em uma variável String chamada "text".

Como posso salvar o conteúdo da variável "texto" em um arquivo?

Se você estiver simplesmente produzindo texto, em vez de quaisquer dados binários, o seguinte funcionará:

PrintWriter out = new PrintWriter("filename.txt");

Em seguida, escreva sua String, como faria em qualquer fluxo de saída:

out.println(text);

Você precisará de tratamento de exceção, como sempre. Certifique-se de ligarout.close() quando terminar de escrever.

Se você estiver usando o Java 7 ou posterior, poderá usar a " instrução try-with-resources ", que fechará automaticamente PrintStreamquando você terminar (por exemplo, sair do bloco) da seguinte maneira:

try (PrintWriter out = new PrintWriter("filename.txt")) {
    out.println(text);
}

Você ainda precisará lançar explicitamente o java.io.FileNotFoundExceptioncomo antes.

O Apache Commons IO contém ótimos métodos para fazer isso, em particular o FileUtils contém o seguinte método:

static void writeStringToFile(File file, String data) 

que permite escrever texto em um arquivo em uma chamada de método:

FileUtils.writeStringToFile(new File("test.txt"), "Hello File");

Você também pode querer especificar a codificação do arquivo.

Dê uma olhada na API de arquivos Java

um exemplo rápido:

try (PrintStream out = new PrintStream(new FileOutputStream("filename.txt"))) {
    out.print(text);
}

No Java 7, você pode fazer isso:

String content = "Hello File!";
String path = "C:/a.txt";
Files.write( Paths.get(path), content.getBytes());

Há mais informações aqui: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

Acabei de fazer algo semelhante no meu projeto. O uso do FileWriter simplificará parte do seu trabalho. E aqui você pode encontrar um bom tutorial .

BufferedWriter writer = null;
try
{
    writer = new BufferedWriter( new FileWriter( yourfilename));
    writer.write( yourstring);

}
catch ( IOException e)
{
}
finally
{
    try
    {
        if ( writer != null)
        writer.close( );
    }
    catch ( IOException e)
    {
    }
}

Use FileUtils.writeStringToFile()do Apache Commons IO . Não há necessidade de reinventar essa roda em particular.

Você pode modificar o código abaixo para gravar seu arquivo de qualquer classe ou função que esteja manipulando o texto. É de se perguntar por que o mundo precisa de um novo editor de texto ...

import java.io.*;

public class Main {

    public static void main(String[] args) {

        try {
            String str = "SomeMoreTextIsHere";
            File newTextFile = new File("C:/thetextfile.txt");

            FileWriter fw = new FileWriter(newTextFile);
            fw.write(str);
            fw.close();

        } catch (IOException iox) {
            //do stuff with exception
            iox.printStackTrace();
        }
    }
}

No Java 11, a java.nio.file.Filesclasse foi estendida por dois novos métodos utilitários para gravar uma string em um arquivo. O primeiro método (consulte JavaDoc aqui ) usa o conjunto de caracteres UTF-8 como padrão:

Files.writeString(Path.of("my", "path"), "My String");

E o segundo método (consulte JavaDoc aqui ) permite especificar um conjunto de caracteres individual:

Files.writeString(Path.of("my", "path"), "My String", StandardCharset.ISO_8859_1);

Ambos os métodos têm um parâmetro Varargs opcional para definir opções de manipulação de arquivos (consulte JavaDoc aqui ). O exemplo a seguir criaria um arquivo inexistente ou anexaria a sequência a um existente:

Files.writeString(Path.of("my", "path"), "String to append", StandardOpenOption.CREATE, StandardOpenOption.APPEND);

Prefiro confiar nas bibliotecas sempre que possível para esse tipo de operação. Isso me deixa menos propenso a omitir acidentalmente um passo importante (como erro cometido pelos lobos acima). Algumas bibliotecas são sugeridas acima, mas a minha favorita para esse tipo de coisa é o Google Guava . O Goiaba possui uma classe chamada Arquivos, que funciona muito bem para esta tarefa:

// This is where the file goes.
File destination = new File("file.txt");
// This line isn't needed, but is really useful 
// if you're a beginner and don't know where your file is going to end up.
System.out.println(destination.getAbsolutePath());
try {
    Files.write(text, destination, Charset.forName("UTF-8"));
} catch (IOException e) {
    // Useful error handling here
}

Use o Apache Commons IO api. É simples

Use API como

 FileUtils.writeStringToFile(new File("FileNameToWrite.txt"), "stringToWrite");

Dependência do Maven

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>

Caso você precise criar um arquivo de texto com base em uma única sequência:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class StringWriteSample {
    public static void main(String[] args) {
        String text = "This is text to be saved in file";

        try {
            Files.write(Paths.get("my-file.txt"), text.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Use isto, é muito legível:

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

Files.write(Paths.get(path), lines.getBytes(), StandardOpenOption.WRITE);

import java.io.*;

private void stringToFile( String text, String fileName )
 {
 try
 {
    File file = new File( fileName );

    // if file doesnt exists, then create it 
    if ( ! file.exists( ) )
    {
        file.createNewFile( );
    }

    FileWriter fw = new FileWriter( file.getAbsoluteFile( ) );
    BufferedWriter bw = new BufferedWriter( fw );
    bw.write( text );
    bw.close( );
    //System.out.println("Done writing to " + fileName); //For testing 
 }
 catch( IOException e )
 {
 System.out.println("Error: " + e);
 e.printStackTrace( );
 }
} //End method stringToFile

Você pode inserir esse método em suas classes. Se você estiver usando esse método em uma classe com um método principal, altere essa classe para estática adicionando a palavra-chave estática. De qualquer forma, você precisará importar o java.io. * para fazê-lo funcionar, caso contrário, File, FileWriter e BufferedWriter não serão reconhecidos.

Você poderia fazer isso:

import java.io.*;
import java.util.*;

class WriteText
{
    public static void main(String[] args)
    {   
        try {
            String text = "Your sample content to save in a text file.";
            BufferedWriter out = new BufferedWriter(new FileWriter("sample.txt"));
            out.write(text);
            out.close();
        }
        catch (IOException e)
        {
            System.out.println("Exception ");       
        }

        return ;
    }
};

Usando Java 7:

public static void writeToFile(String text, String targetFilePath) throws IOException
{
    Path targetPath = Paths.get(targetFilePath);
    byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
    Files.write(targetPath, bytes, StandardOpenOption.CREATE);
}

Usando org.apache.commons.io.FileUtils:

FileUtils.writeStringToFile(new File("log.txt"), "my string", Charset.defaultCharset());

Se você se preocupa apenas em enviar um bloco de texto para o arquivo, ele será sobrescrito a cada vez.

JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showSaveDialog(this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
    FileOutputStream stream = null;
    PrintStream out = null;
    try {
        File file = chooser.getSelectedFile();
        stream = new FileOutputStream(file); 
        String text = "Your String goes here";
        out = new PrintStream(stream);
        out.print(text);                  //This will overwrite existing contents

    } catch (Exception ex) {
        //do something
    } finally {
        try {
            if(stream!=null) stream.close();
            if(out!=null) out.close();
        } catch (Exception ex) {
            //do something
        }
    }
}

Este exemplo permite que o usuário selecione um arquivo usando um seletor de arquivos.

É melhor fechar o gravador / fluxo de saída em um bloco final, caso algo aconteça

finally{
   if(writer != null){
     try{
        writer.flush();
        writer.close();
     }
     catch(IOException ioe){
         ioe.printStackTrace();
     }
   }
}

private static void generateFile(String stringToWrite, String outputFile) {
try {       
    FileWriter writer = new FileWriter(outputFile);
    writer.append(stringToWrite);
    writer.flush();
    writer.close();
    log.debug("New File is generated ==>"+outputFile);
} catch (Exception exp) {
    log.error("Exception in generateFile ", exp);
}

}

Eu acho que a melhor maneira é usar Files.write(Path path, Iterable<? extends CharSequence> lines, OpenOption... options):

String text = "content";
Path path = Paths.get("path", "to", "file");
Files.write(path, Arrays.asList(text));

Veja javadoc :

Escreva linhas de texto em um arquivo. Cada linha é uma sequência de caracteres e é gravada no arquivo em sequência com cada linha terminada pelo separador de linhas da plataforma, conforme definido pela propriedade do sistema line.separator. Os caracteres são codificados em bytes usando o conjunto de caracteres especificado.

O parâmetro options especifica como o arquivo é criado ou aberto. Se nenhuma opção estiver presente, esse método funcionará como se as opções CREATE, TRUNCATE_EXISTING e WRITE estivessem presentes. Em outras palavras, ele abre o arquivo para gravação, criação do arquivo se ele não existir ou truncamento inicial de um arquivo regular existente para um tamanho de 0. O método garante que o arquivo seja fechado quando todas as linhas forem gravadas ( ou um erro de E / S ou outra exceção de tempo de execução). Se ocorrer um erro de E / S, poderá ocorrer após o arquivo ter sido criado ou truncado ou após a gravação de alguns bytes no arquivo.

Observe. Vejo que as pessoas já responderam com o Java embutido Files.write, mas o que é especial na minha resposta, que ninguém parece mencionar, é a versão sobrecarregada do método, que utiliza um Iterable de CharSequence (ou seja, String), em vez de uma byte[]matriz, portanto, text.getBytes()não é necessário. , que é um pouco mais limpo, eu acho.

Se você deseja manter os caracteres de retorno de carro da string em um arquivo, aqui está um exemplo de código:

    jLabel1 = new JLabel("Enter SQL Statements or SQL Commands:");
    orderButton = new JButton("Execute");
    textArea = new JTextArea();
    ...


    // String captured from JTextArea()
    orderButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent ae) {
            // When Execute button is pressed
            String tempQuery = textArea.getText();
            tempQuery = tempQuery.replaceAll("\n", "\r\n");
            try (PrintStream out = new PrintStream(new FileOutputStream("C:/Temp/tempQuery.sql"))) {
                out.print(tempQuery);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(tempQuery);
        }

    });

Meu caminho é baseado no fluxo devido à execução em todas as versões do Android e nas necessidades de recursos adequados, como URL / URI, qualquer sugestão é bem-vinda.

No que diz respeito a fluxos, os fluxos (InputStream e OutputStream) transferem dados binários, quando o desenvolvedor grava uma sequência em um fluxo, deve primeiro convertê-los em bytes ou, em outras palavras, codificá-los.

public boolean writeStringToFile(File file, String string, Charset charset) {
    if (file == null) return false;
    if (string == null) return false;
    return writeBytesToFile(file, string.getBytes((charset == null) ? DEFAULT_CHARSET:charset));
}

public boolean writeBytesToFile(File file, byte[] data) {
    if (file == null) return false;
    if (data == null) return false;
    FileOutputStream fos;
    BufferedOutputStream bos;
    try {
        fos = new FileOutputStream(file);
        bos = new BufferedOutputStream(fos);
        bos.write(data, 0, data.length);
        bos.flush();
        bos.close();
        fos.close();
    } catch (IOException e) {
        e.printStackTrace();
        Logger.e("!!! IOException");
        return false;
    }
    return true;
}

Você pode usar o ArrayList para colocar todo o conteúdo da TextArea por exemplo, e enviar como parâmetro chamando o save, como o escritor acabou de escrever as linhas da string, então usamos o "for" linha por linha para escrever nosso ArrayList no final estaremos conteúdo TextArea no arquivo txt. se algo não faz sentido, me desculpe é o google tradutor e eu que não falamos inglês.

Assista ao bloco de notas do Windows, ele nem sempre pula linhas e mostra tudo em uma linha, use o Wordpad ok.

private void SaveActionPerformed(java.awt.event.ActionEvent evt) {

    String NameFile = Name.getText();
    ArrayList< String > Text = new ArrayList< String >();

    Text.add(TextArea.getText());

    SaveFile(NameFile, Text);
}

public void SaveFile(String name, ArrayList< String> message) {

    path = "C:\\Users\\Paulo Brito\\Desktop\\" + name + ".txt";

    File file1 = new File(path);

    try {

        if (!file1.exists()) {

            file1.createNewFile();
        }


        File[] files = file1.listFiles();


        FileWriter fw = new FileWriter(file1, true);

        BufferedWriter bw = new BufferedWriter(fw);

        for (int i = 0; i < message.size(); i++) {

            bw.write(message.get(i));
            bw.newLine();
        }

        bw.close();
        fw.close();

        FileReader fr = new FileReader(file1);

        BufferedReader br = new BufferedReader(fr);

        fw = new FileWriter(file1, true);

        bw = new BufferedWriter(fw);

        while (br.ready()) {

            String line = br.readLine();

            System.out.println(line);

            bw.write(line);
            bw.newLine();

        }
        br.close();
        fr.close();

    } catch (IOException ex) {
        ex.printStackTrace();
        JOptionPane.showMessageDialog(null, "Error in" + ex);     
    }   
}