Como crio um arquivo e o escrevo em Java?


1383

Qual é a maneira mais simples de criar e gravar em um arquivo (texto) em Java?

Respostas:


1735

Observe que cada uma das amostras de código abaixo pode ser lançada IOException. Os blocos try / catch / finalmente foram omitidos por questões de brevidade. Consulte este tutorial para obter informações sobre o tratamento de exceções.

Observe que cada um dos exemplos de código abaixo substituirá o arquivo se ele já existir

Criando um arquivo de texto:

PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8");
writer.println("The first line");
writer.println("The second line");
writer.close();

Criando um arquivo binário:

byte data[] = ...
FileOutputStream out = new FileOutputStream("the-file-name");
out.write(data);
out.close();

Os usuários do Java 7+ podem usar a Filesclasse para gravar em arquivos:

Criando um arquivo de texto:

List<String> lines = Arrays.asList("The first line", "The second line");
Path file = Paths.get("the-file-name.txt");
Files.write(file, lines, StandardCharsets.UTF_8);
//Files.write(file, lines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);

Criando um arquivo binário:

byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);

58
Digno de nota PrintWriter irá truncar o tamanho do arquivo para zero se o arquivo já existe
Covar

34
O PrintWriter pode ser (e geralmente é) usado, mas não é (conceitualmente) a classe certa para o trabalho. Dos documentos: "PrintWriter prints formatted representations of objects to a text-output stream. "a resposta do Bozho é mais correta, embora pareça complicada (você sempre pode envolvê-lo em algum método utilitário).
Leonbloy 21/05

14
Então, onde o arquivo de texto será criado depois que o aplicativo for compilado e usado em outro PC, pois não fornecemos o caminho?
Marlon Abeykoon

13
@MarlonAbeykoon Good question. A resposta é que ele criará o arquivo de texto no diretório de trabalho . O diretório de trabalho é o diretório em que você executa seu programa. Por exemplo, se você executar seu programa a partir da linha de comando, o diretório de trabalho será o diretório em que você está "nesse momento" (no Linux, digite "pwd" para ver o diretório de trabalho atual). Ou, se clicar duas vezes em um arquivo JAR na área de trabalho para executá-lo, o diretório de trabalho será a área de trabalho.
Michael

8
writer.close()deve estar em um bloco finalmente
Thierry

416

No Java 7 e superior:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(
              new FileOutputStream("filename.txt"), "utf-8"))) {
   writer.write("something");
}

Existem utilitários úteis para isso:

Observe também que você pode usar a FileWriter, mas ela usa a codificação padrão, o que geralmente é uma má idéia - é melhor especificar a codificação explicitamente.

Abaixo está a resposta original anterior ao Java 7


Writer writer = null;

try {
    writer = new BufferedWriter(new OutputStreamWriter(
          new FileOutputStream("filename.txt"), "utf-8"));
    writer.write("Something");
} catch (IOException ex) {
    // Report
} finally {
   try {writer.close();} catch (Exception ex) {/*ignore*/}
}

Consulte também: Leitura, gravação e criação de arquivos (inclui NIO2).


5
@leonbloy Eu sei que este é um comentário antigo, mas se alguém vir isso, você se importaria de explicar por que nem sempre é "benéfico"? Pelo menos aqui diz "top eficiente" docs.oracle.com/javase/1.5.0/docs/api/java/io/…
Juan

14
Parece que o writer não possui um método writeln (). Ele só tem write () #
11333 YankeeWhiskey

10
Se você alterar o tipo de gravador para BufferedWriter (o que realmente é), poderá usar o writer.newLine ()
Niek

4
Não parece certo tentar / capturar dentro de um finalmente. Eu sei o motivo, mas parece um cheiro de código.
precisa saber é o seguinte

4
@Trengot Sim. A chamada close()de qualquer fluxo enrolado em qualquer outro fechará também todos os fluxos internos.
Fund Monica's Lawsuit

132

Se você já possui o conteúdo que deseja gravar no arquivo (e não é gerado rapidamente), a java.nio.file.Filesadição no Java 7 como parte da E / S nativa fornece a maneira mais simples e eficiente de atingir seus objetivos.

Basicamente, criar e gravar em um arquivo é apenas uma linha, além de uma simples chamada de método !

O exemplo a seguir cria e grava em 6 arquivos diferentes para mostrar como ele pode ser usado:

Charset utf8 = StandardCharsets.UTF_8;
List<String> lines = Arrays.asList("1st line", "2nd line");
byte[] data = {1, 2, 3, 4, 5};

try {
    Files.write(Paths.get("file1.bin"), data);
    Files.write(Paths.get("file2.bin"), data,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
    Files.write(Paths.get("file3.txt"), "content".getBytes());
    Files.write(Paths.get("file4.txt"), "content".getBytes(utf8));
    Files.write(Paths.get("file5.txt"), lines, utf8);
    Files.write(Paths.get("file6.txt"), lines, utf8,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
} catch (IOException e) {
    e.printStackTrace();
}

Bem feito. Eu gosto do exemplo file5 e file6. Para testar o arquivo6, certifique-se de executar o programa duas vezes, e você verá que ele anexa as linhas novamente.
tazboy

76
public class Program {
    public static void main(String[] args) {
        String text = "Hello world";
        BufferedWriter output = null;
        try {
            File file = new File("example.txt");
            output = new BufferedWriter(new FileWriter(file));
            output.write(text);
        } catch ( IOException e ) {
            e.printStackTrace();
        } finally {
          if ( output != null ) {
            output.close();
          }
        }
    }
}

18
Não seria melhor colocar output.close () em um bloco finalmente?
qed

7
O mero código nunca pode constituir uma resposta aqui. Você tem que explicar.
Marquês de Lorne

7
na verdade, isso não irá compilar, output.close()lança IOException
Bob Yoplait

43

Aqui está um pequeno exemplo de programa para criar ou substituir um arquivo. É a versão longa, para que possa ser entendida com mais facilidade.

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class writer {
    public void writing() {
        try {
            //Whatever the file path is.
            File statText = new File("E:/Java/Reference/bin/images/statsTest.txt");
            FileOutputStream is = new FileOutputStream(statText);
            OutputStreamWriter osw = new OutputStreamWriter(is);    
            Writer w = new BufferedWriter(osw);
            w.write("POTATO!!!");
            w.close();
        } catch (IOException e) {
            System.err.println("Problem writing to the file statsTest.txt");
        }
    }

    public static void main(String[]args) {
        writer write = new writer();
        write.writing();
    }
}

39

Uma maneira muito simples de criar e gravar em um arquivo em Java:

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

public class CreateFiles {

    public static void main(String[] args) {
        try{
            // Create new file
            String content = "This is the content to write into create file";
            String path="D:\\a\\hi.txt";
            File file = new File(path);

            // If file doesn't exists, then create it
            if (!file.exists()) {
                file.createNewFile();
            }

            FileWriter fw = new FileWriter(file.getAbsoluteFile());
            BufferedWriter bw = new BufferedWriter(fw);

            // Write in file
            bw.write(content);

            // Close connection
            bw.close();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
}

7
O File.exists()/createNewFile()código aqui é inútil e inútil. O sistema operacional já precisa fazer exatamente a mesma coisa quando ele new FileWriter()é criado. Você está forçando tudo a acontecer duas vezes.
Marquês de Lorne

1
O File.exists () / createNewFile () não é inútil e desperdício. Eu estava procurando uma maneira de executar código diferente com base no fato de o arquivo já estar presente ou não. Isso foi muito útil.
KirstieBallance

2
Eu usei esse método, mas você deve saber que ele substitui o arquivo toda vez. Se você deseja anexá-lo caso o arquivo exista, instale da FileWriterseguinte maneira: #new FileWriter(file.getAbsoluteFile(),true)
Adelin

2
É tanto inútil e perdulário, pela razão de que eu disse. Você está fazendo com que dois testes de existência, duas criações, e uma deleção: e você está não execução de código diferente aqui, dependendo ou não o arquivo já está presente.
Marquês de Lorne

34

Usar:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) {
    writer.write("text to write");
} 
catch (IOException ex) {
    // Handle me
}  

Usar try()fechará o fluxo automaticamente. Esta versão é curta, rápida (em buffer) e permite escolher a codificação.

Esse recurso foi introduzido no Java 7.


5
Deve-se notar que esse é um recurso do Java 7, portanto não funcionará nas versões anteriores do Java.
Dan Temple

3
Pode-se usar a "constante" em StandardCharsets.UTF_8vez da string "utf-8" (isso evita falhas de digitação) ...new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8)...- java.nio.charset.StandardCharsetsé introduzida no java 7
Ralph

20

Aqui estamos inserindo uma string em um arquivo de texto:

String content = "This is the content to write into a file";
File file = new File("filename.txt");
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close(); // Be sure to close BufferedWriter

Podemos facilmente criar um novo arquivo e adicionar conteúdo a ele.


Observe que fechar o BufferedWriter é suficiente, pois ele também cuida do fechamento do FileWriter.
precisa saber é o seguinte

17

Como o autor não especificou se eles exigem uma solução para versões Java que foram EoL'd (tanto pela Sun quanto pela IBM, e estas são tecnicamente as JVMs mais difundidas), e devido ao fato de que muitas pessoas parecem ter respondido ao pergunta do autor antes de ser especificado que é um arquivo de texto (não binário) , decidi fornecer minha resposta.


Em primeiro lugar, o Java 6 geralmente chegou ao fim da vida útil e, como o autor não especificou que ele precisa de compatibilidade com legados, acho que significa automaticamente o Java 7 ou superior (o Java 7 ainda não foi aprovado pela IBM). Portanto, podemos ver o tutorial de E / S do arquivo: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Antes do lançamento do Java SE 7, a classe java.io.File era o mecanismo usado para a E / S do arquivo, mas tinha várias desvantagens.

  • Muitos métodos não lançaram exceções quando falharam; portanto, era impossível obter uma mensagem de erro útil. Por exemplo, se uma exclusão de arquivo falhasse, o programa receberia uma "falha de exclusão", mas não saberia se era porque o arquivo não existia, o usuário não tinha permissões ou havia outro problema.
  • O método de renomeação não funcionou consistentemente entre plataformas.
  • Não havia suporte real para links simbólicos.
  • Foi desejado mais suporte para metadados, como permissões de arquivo, proprietário do arquivo e outros atributos de segurança. O acesso aos metadados do arquivo foi ineficiente.
  • Muitos dos métodos de arquivo não foram dimensionados. Solicitar uma listagem de diretório grande em um servidor pode resultar em um travamento. Diretórios grandes também podem causar problemas de recursos de memória, resultando em uma negação de serviço.
  • Não foi possível escrever um código confiável que pudesse percorrer recursivamente uma árvore de arquivos e responder adequadamente se houvesse links simbólicos circulares.

Bem, isso exclui o java.io.File. Se um arquivo não puder ser gravado / anexado, talvez você nem saiba o porquê.


Podemos continuar consultando o tutorial: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Se você tiver todas as linhas que escreverá (anexa) no arquivo de texto com antecedência , a abordagem recomendada é https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# Você pode usar o seguinte comando: java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption ...-

Aqui está um exemplo (simplificado):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, StandardCharsets.UTF_8);

Outro exemplo (anexar):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);

Se você deseja gravar o conteúdo do arquivo, vá para : https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#newBufferedWriter-java.nio.file.Path-java .nio.charset.Charset-java.nio.file.OpenOption ...-

Exemplo simplificado (Java 8 ou superior):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
    writer.append("Zero header: ").append('0').write("\r\n");
    [...]
}

Outro exemplo (anexar):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) {
    writer.write("----------");
    [...]
}

Esses métodos exigem um esforço mínimo da parte do autor e devem ser preferidos a todos os outros ao serem gravados em arquivos [texto].


'Se um arquivo não puder ser gravado / anexado, talvez você nem saiba por que' não está correto. Você saberá exatamente por que, a partir do texto FileNotFoundExceptionque é lançado quando a operação falha.
Marquês de Lorne

"Muitos métodos não lançaram exceções quando falharam, por isso era impossível obter uma mensagem de erro útil. Por exemplo, se uma exclusão de arquivo falhar, o programa receberá uma" falha de exclusão ", mas não saberá se foi porque o arquivo não existia, o usuário não tinha permissões ou havia outro problema ".
Afk5min 28/11/16

Leia o que eu escrevi. ' Se um arquivo não puder ser gravado / anexado, talvez você nem consiga obter uma mensagem de erro útil' está incorreto, pelo motivo que afirmei, e permanece. Você está mudando de assunto. Seu próprio assunto.
Marquês de Lorne

Examinarei as implementações internas para sistemas de arquivos típicos (que seriam no OpenJDK, mas não tenho motivos para pensar que essa parte seja diferente no Oracle JDK proprietário ou significativamente diferente no IBM JDK proprietário, entre outros) e atualize minha resposta com base nessas descobertas. Seu comentário faz sentido - só porque 'muitos métodos' podem ter problemas, o autor afirmou claramente que é apenas a operação de gravação / anexação ao arquivo com a qual eles se preocupam.
precisa saber é o seguinte

O motivo é que nenhum dos métodos que você está chamando falha ao lançar exceções apropriadas contendo mensagens de erro apropriadas. Se você tiver um contra-exemplo que suporte sua afirmação, é sua responsabilidade fornecê-la.
Marquês de Lorne

16

Se você deseja ter uma experiência relativamente simples, também pode dar uma olhada no pacote Apache Commons IO , mais especificamente na FileUtilsclasse .

Nunca se esqueça de verificar as bibliotecas de terceiros. Joda-Time para manipulação de datas, Apache Commons LangStringUtils para operações comuns de strings e isso pode tornar seu código mais legível.

Java é uma ótima linguagem, mas a biblioteca padrão às vezes é um pouco de baixo nível. Poderoso, mas de baixo nível, no entanto.


1
O método mais simples de gravação de arquivos FileUtilsé o static void write(File file, CharSequence data). Exemplo de utilização: import org.apache.commons.io.FileUtils; FileUtils.write(new File("example.txt"), "string with data");. FileUtilstambém tem writeLines, o que leva uma Collectiondas linhas.
Rory O'Kane

12

Se, por algum motivo, você quiser separar o ato de criar e gravar, o equivalente em Java de touché

try {
   //create a file named "testfile.txt" in the current working directory
   File myFile = new File("testfile.txt");
   if ( myFile.createNewFile() ) {
      System.out.println("Success!");
   } else {
      System.out.println("Failure!");
   }
} catch ( IOException ioe ) { ioe.printStackTrace(); }

createNewFile()faz uma verificação de existência e um arquivo é criado atomicamente. Isso pode ser útil se você quiser garantir que você foi o criador do arquivo antes de gravá-lo, por exemplo.


1
[touch] também atualiza o registro de data e hora do arquivo como um efeito colateral (se ele já existir). Isso também tem esse efeito colateral?
Ape-inago 21/08

@ Ape-inago: No meu sistema, certamente não o fez (apenas retorna falso e não tem efeito no arquivo). Não quis dizer touchno sentido geral, mas em seu uso secundário comum, criar um arquivo sem gravar dados nele. O objetivo documentado do toque é atualizar o registro de data e hora no arquivo. Criar o arquivo se ele não existir é realmente o efeito colateral e pode ser desativado com uma opção.
Mark Peters

Por alguma razão, como o quê? Essas exists()/createNewFile()seqüências são literalmente um desperdício de tempo e espaço.
Marquês de Lorne

12

Aqui estão algumas das maneiras possíveis de criar e gravar um arquivo em Java:

Usando FileOutputStream

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
  bw.write("Write somthing to the file ...");
  bw.newLine();
  bw.close();
} catch (FileNotFoundException e){
  // File was not found
  e.printStackTrace();
} catch (IOException e) {
  // Problem when writing to the file
  e.printStackTrace();
}

Usando FileWriter

try {
  FileWriter fw = new FileWriter("myOutFile.txt");
  fw.write("Example of content");
  fw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Usando PrintWriter

try {
  PrintWriter pw = new PrintWriter("myOutFile.txt");
  pw.write("Example of content");
  pw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Usando OutputStreamWriter

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  osw.write("Soe content ...");
  osw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Para mais informações, consulte este tutorial sobre Como ler e gravar arquivos em Java .


Apenas imaginando ... não deveria FileWriterou deveria OutputStreamWriterser fechado em um bloco finalmente?
Wolfgang Schreurs

@WolfgangSchreurs, Sim, é ainda melhor, tenho que mover a declaração da variável para fora do bloco try para poder fazer isso.
Mehdi

Acabei de descobrir que, ao usar o fechamento automático, mesmo que seja mais limpo, não é necessário declarar variável fora do bloco e os recursos serão fechados automaticamente, mesmo que ocorra uma exceção (é necessário adicionar explicitamente um bloco final). Veja: docs.oracle.com/javase/tutorial/essential/exceptions/…
Wolfgang Schreurs

Eu adicionaria a tentativa com recursos como um exemplo separado (para separar diferentes possibilidades). Você sabe que SOF é um site colaborativo, vá em frente e modifique a resposta, se quiser ter o direito.
Mehdi

10

Usar:

JFileChooser c = new JFileChooser();
c.showOpenDialog(c);
File writeFile = c.getSelectedFile();
String content = "Input the data here to be written to your file";

try {
    FileWriter fw = new FileWriter(writeFile);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.append(content);
    bw.append("hiiiii");
    bw.close();
    fw.close();
}
catch (Exception exc) {
   System.out.println(exc);
}

esta é a maneira mais fácil que eu encontrei ... todos os problemas são resolvidos aqui e é necessário apenas o texto a ser inserido
Rohit ZP

10

A melhor maneira é usar o Java7: o Java 7 apresenta uma nova maneira de trabalhar com o sistema de arquivos, juntamente com uma nova classe de utilitário - Arquivos. Usando a classe Files, podemos criar, mover, copiar, excluir arquivos e diretórios também; também pode ser usado para ler e gravar em um arquivo.

public void saveDataInFile(String data) throws IOException {
    Path path = Paths.get(fileName);
    byte[] strToBytes = data.getBytes();

    Files.write(path, strToBytes);
}

Gravação com FileChannel Se você estiver lidando com arquivos grandes, o FileChannel poderá ser mais rápido que o IO padrão. O código a seguir grava String em um arquivo usando o FileChannel:

public void saveDataInFile(String data) 
  throws IOException {
    RandomAccessFile stream = new RandomAccessFile(fileName, "rw");
    FileChannel channel = stream.getChannel();
    byte[] strBytes = data.getBytes();
    ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
    buffer.put(strBytes);
    buffer.flip();
    channel.write(buffer);
    stream.close();
    channel.close();
}

Escreva com DataOutputStream

public void saveDataInFile(String data) throws IOException {
    FileOutputStream fos = new FileOutputStream(fileName);
    DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos));
    outStream.writeUTF(data);
    outStream.close();
}

Escreva com FileOutputStream

Vamos agora ver como podemos usar o FileOutputStream para gravar dados binários em um arquivo. O código a seguir converte um String int bytes e grava os bytes no arquivo usando um FileOutputStream:

public void saveDataInFile(String data) throws IOException {
    FileOutputStream outputStream = new FileOutputStream(fileName);
    byte[] strToBytes = data.getBytes();
    outputStream.write(strToBytes);

    outputStream.close();
}

Escreva com PrintWriter , podemos usar um PrintWriter para escrever texto formatado em um arquivo:

public void saveDataInFile() throws IOException {
    FileWriter fileWriter = new FileWriter(fileName);
    PrintWriter printWriter = new PrintWriter(fileWriter);
    printWriter.print("Some String");
    printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000);
    printWriter.close();
}

Escreva com BufferedWriter: use BufferedWriter para gravar uma String em um novo arquivo:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
    writer.write(data);

    writer.close();
}

anexe uma String ao arquivo existente:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
    writer.append(' ');
    writer.append(data);

    writer.close();
}

9

Eu acho que este é o caminho mais curto:

FileWriter fr = new FileWriter("your_file_name.txt"); // After '.' write
// your file extention (".txt" in this case)
fr.write("Things you want to write into the file"); // Warning: this will REPLACE your old file content!
fr.close();

8

Para criar um arquivo sem substituir o arquivo existente:

System.out.println("Choose folder to create file");
JFileChooser c = new JFileChooser();
c.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
c.showOpenDialog(c);
c.getSelectedFile();
f = c.getSelectedFile(); // File f - global variable
String newfile = f + "\\hi.doc";//.txt or .doc or .html
File file = new File(newfile);

try {
    //System.out.println(f);
    boolean flag = file.createNewFile();

    if(flag == true) {
        JOptionPane.showMessageDialog(rootPane, "File created successfully");
    }
    else {
        JOptionPane.showMessageDialog(rootPane, "File already exists");
    }
    /* Or use exists() function as follows:
        if(file.exists() == true) {
            JOptionPane.showMessageDialog(rootPane, "File already exists");
        }
        else {
            JOptionPane.showMessageDialog(rootPane, "File created successfully");
        }
    */
}
catch(Exception e) {
    // Any exception handling method of your choice
}

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

public class FileWriterExample {
    public static void main(String [] args) {
        FileWriter fw= null;
        File file =null;
        try {
            file=new File("WriteFile.txt");
            if(!file.exists()) {
                file.createNewFile();
            }
            fw = new FileWriter(file);
            fw.write("This is an string written to a file");
            fw.flush();
            fw.close();
            System.out.println("File written Succesfully");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Essas exists()/createNewFile()seqüências são literalmente um desperdício de tempo e espaço.
Marquês de Lorne

6
package fileoperations;
import java.io.File;
import java.io.IOException;

public class SimpleFile {
    public static void main(String[] args) throws IOException {
        File file =new File("text.txt");
        file.createNewFile();
        System.out.println("File is created");
        FileWriter writer = new FileWriter(file);

        // Writes the content to the file
        writer.write("Enter the text that you want to write"); 
        writer.flush();
        writer.close();
        System.out.println("Data is entered into file");
    }
}

Essas exists()/createNewFile()seqüências são literalmente um desperdício de tempo e espaço.
Marquês de Lorne

5

Apenas uma linha! pathe linesão cordas

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

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

Ahem, o autor especificou explicitamente os arquivos "texto". E os arquivos de texto são compostos de caracteres. Arquivos binários são compostos de bytes. Além disso, não está claro o que é lines. Se for um java.lang.String, a chamada getBytes()produzirá bytes usando a codificação padrão da plataforma , o que não é muito bom no caso geral.
Afk5min

5

A maneira mais simples de encontrar:

Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
    writer.write("Hello, world!");
}

Provavelmente funcionará apenas para 1.7+.


5

Vale a pena tentar para o Java 7+:

 Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());

Parece promissor ...


4

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

4

Leitura e gravação de arquivos usando entrada e saída:

//Coded By Anurag Goel
//Reading And Writing Files
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


public class WriteAFile {
    public static void main(String args[]) {
        try {
            byte array [] = {'1','a','2','b','5'};
            OutputStream os = new FileOutputStream("test.txt");
            for(int x=0; x < array.length ; x++) {
                os.write( array[x] ); // Writes the bytes
            }
            os.close();

            InputStream is = new FileInputStream("test.txt");
            int size = is.available();

            for(int i=0; i< size; i++) {
                System.out.print((char)is.read() + " ");
            }
            is.close();
        } catch(IOException e) {
            System.out.print("Exception");
        }
    }
}

4

Basta incluir este pacote:

java.nio.file

E então você pode usar este código para escrever o arquivo:

Path file = ...;
byte[] buf = ...;
Files.write(file, buf);

4

No Java 8, use Arquivos e caminhos e a construção try-with-resources.

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

public class WriteFile{
    public static void main(String[] args) throws IOException {
        String file = "text.txt";
        System.out.println("Writing to file: " + file);
        // Files.newBufferedWriter() uses UTF-8 encoding by default
        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(file))) {
            writer.write("Java\n");
            writer.write("Python\n");
            writer.write("Clojure\n");
            writer.write("Scala\n");
            writer.write("JavaScript\n");
        } // the file will be automatically closed
    }
}

3

Existem algumas maneiras simples, como:

File file = new File("filename.txt");
PrintWriter pw = new PrintWriter(file);

pw.write("The world I'm coming");
pw.close();

String write = "Hello World!";

FileWriter fw = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(fw);

fw.write(write);

fw.close();

bwestá sem uso.
Marquês de Lorne #

E o ponto de sobrescrever o arquivo com novo conteúdo não é indicado.
Marquês de Lorne

3

Você pode até criar um arquivo temporário usando uma propriedade do sistema , que será independente do sistema operacional em uso.

File file = new File(System.*getProperty*("java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");

2

Usando a biblioteca Guava do Google, podemos criar e gravar em um arquivo com muita facilidade.

package com.zetcode.writetofileex;

import com.google.common.io.Files;
import java.io.File;
import java.io.IOException;

public class WriteToFileEx {

    public static void main(String[] args) throws IOException {

        String fileName = "fruits.txt";
        File file = new File(fileName);

        String content = "banana, orange, lemon, apple, plum";

        Files.write(content.getBytes(), file);
    }
}

O exemplo cria um novo fruits.txtarquivo no diretório raiz do projeto.


2

Lendo coleção com os clientes e salvando em arquivo, com JFilechooser.

private void writeFile(){

    JFileChooser fileChooser = new JFileChooser(this.PATH);
    int retValue = fileChooser.showDialog(this, "Save File");

    if (retValue == JFileChooser.APPROVE_OPTION){

        try (Writer fileWrite = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileChooser.getSelectedFile())))){

            this.customers.forEach((c) ->{
                try{
                    fileWrite.append(c.toString()).append("\n");
                }
                catch (IOException ex){
                    ex.printStackTrace();
                }
            });
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}

2

Existem pelo menos várias maneiras de criar um arquivo e gravá-lo:

Arquivos pequenos (1.7)

Você pode usar um dos métodos de gravação para escrever bytes ou linhas em um arquivo.

Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".;
Files.write(file, buf);

Esses métodos cuidam da maior parte do trabalho para você, como abrir e fechar o fluxo, mas não se destinam ao tratamento de arquivos grandes.

Gravando arquivos maiores usando E / S de fluxo buffer (1.7)

O java.nio.filepacote suporta o canal de E / S, que move dados em buffers, ignorando algumas das camadas que podem causar gargalo no fluxo de E / S.

String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
    writer.write(s, 0, s.length());
}

Essa abordagem é preferencial devido ao seu desempenho eficiente, especialmente ao concluir uma grande quantidade de operações de gravação. As operações em buffer têm esse efeito, pois não precisam chamar o método de gravação do sistema operacional para cada byte, reduzindo as operações de E / S dispendiosas.

Usando a API do NIO para copiar (e criar um novo) um arquivo com um Outputstream (1.7)

Path oldFile = Paths.get("existing-file-path");
Path newFile = Paths.get("new-file-path");
try (OutputStream os = new FileOutputStream(newFile.toFile())) {
    Files.copy(oldFile, os);
}

Existem também métodos adicionais que permitem copiar todos os bytes de um fluxo de entrada para um arquivo.

FileWriter (texto) (<1.7)

Grava diretamente no arquivo (menos desempenho) e deve ser usado apenas quando o número de gravações for menor. Usado para gravar dados orientados a caracteres em um arquivo.

String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();

FileOutputStream (binário) (<1.7)

FileOutputStream destina-se a escrever fluxos de bytes brutos, como dados de imagem.

byte data[] = "binary-to-write-to-file".getBytes();
FileOutputStream out = new FileOutputStream("file-name");
out.write(data);
out.close();

Com essa abordagem, deve-se considerar sempre escrever uma matriz de bytes em vez de escrever um byte de cada vez. A aceleração pode ser bastante significativa - até 10 vezes maior ou mais. Portanto, é recomendável usar os write(byte[])métodos sempre que possível.

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.