Como eu crio um arquivo e escrevo nele em Java?

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

Observe que cada um dos exemplos de código abaixo pode lançar IOException . Os blocos try / catch / finally foram omitidos por brevidade. Veja este tutorial para obter informações sobre manipulação de exceções.

Criando um arquivo de texto (observe que isso sobrescreverá o arquivo, se já existir):

 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 (isso também irá sobrescrever o arquivo):

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

Usuários do Java 7+ podem usar a class Files para gravar em arquivos:

Criando um arquivo de texto:

 List lines = Arrays.asList("The first line", "The second line"); Path file = Paths.get("the-file-name.txt"); Files.write(file, lines, Charset.forName("UTF-8")); //Files.write(file, lines, Charset.forName("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); 

No Java 7 e acima:

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

Existem utilitários úteis para isso:

  • FileUtils.writeStringtoFile (..) de commons-io
  • Files.write (..) de goiaba

Note também que você pode usar um FileWriter , mas ele usa a codificação padrão, o que geralmente é uma má idéia – é melhor especificar a codificação explicitamente.

Abaixo está a resposta original antes do 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*/} } 

Veja também: Leitura, Escrita e Criação de Arquivos (inclui o NIO2).

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

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

Aqui está um pequeno programa de exemplo para criar ou sobrescrever um arquivo. É a versão longa, por isso pode ser entendida mais facilmente.

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

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 } 

Usando try() irá fechar o stream automaticamente. Esta versão é curta, rápida (buffer) e permite a escolha da codificação.

Este recurso foi introduzido no Java 7.

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

Referência: Arquivo criar exemplo em java

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.

Se você deseja ter uma experiência relativamente livre de dor, você também pode dar uma olhada no pacote Apache Commons IO , mais especificamente na class FileUtils .

Nunca esqueça de verificar bibliotecas de terceiros. Joda-Time para manipulação de data, Apache Commons Lang StringUtils para operações de string comuns e tal 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.

Desde que o autor não especificou se eles exigem uma solução para as versões Java que foram EoL (tanto pela Sun quanto pela IBM, e estas são tecnicamente as JVMs mais difundidas), e devido ao fato de que a maioria das pessoas parece ter respondido 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 atingiu o fim da vida e, como o autor não especificou, ele precisa de compatibilidade legada, eu acho que significa automaticamente o Java 7 ou superior (o Java 7 ainda não é EoL da IBM). Assim, podemos ver diretamente o tutorial de E / S de arquivos: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

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

  • Muitos methods não lançaram exceções quando falharam, por isso foi impossível obter uma mensagem de erro útil. Por exemplo, se uma exclusão de arquivo falhou, 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 permissions ou havia algum outro problema.
  • O método de renomeação não funcionou consistentemente nas plataformas.
  • Não houve suporte real para links simbólicos.
  • Mais suporte para metadados foi desejado, como permissions de arquivo, proprietário de arquivo e outros atributos de segurança. Acessar metadados de arquivos era ineficiente.
  • Muitos dos methods File não foram dimensionados. Solicitar uma listview de diretórios grande em um servidor pode resultar em interrupção. Diretórios grandes também podem causar problemas de resources de memory, resultando em uma negação de serviço.
  • Não foi possível escrever código confiável que pudesse percorrer recursivamente uma tree de arquivos e responder apropriadamente se houvesse links simbólicos circulares.

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


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

Se você tiver todas as linhas, você escreverá (anexa) ao arquivo de texto antecipadamente , a abordagem recomendada é https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# write-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption …-

Aqui está um exemplo (simplificado):

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

Outro exemplo (acrescentar):

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

Se você deseja gravar o conteúdo do arquivo à sua medida : 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 (acrescentar):

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

Esses methods requerem um esforço mínimo por parte do autor e devem ser preferidos a todos os outros quando se escreve para arquivos [texto].

Se você, por algum motivo, quiser separar o ato de criar e escrever, o equivalente Java do 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 arquivo cria atomicamente. Isso pode ser útil se você quiser garantir que você era o criador do arquivo antes de gravar nele, por exemplo.

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

Eu acho que esse é 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(); 

Para criar um arquivo sem sobrescrever 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 } 
 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(); } } } 
 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"); } } 

Apenas uma linha! path e line são Strings

 import java.nio.file.Files; import java.nio.file.Paths; Files.write(Paths.get(path), lines.getBytes()); 

A maneira mais simples que posso encontrar:

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

Provavelmente funcionará apenas para 1.7+.

Se estamos usando o Java 7 e acima e também sabemos o conteúdo a ser adicionado (anexado) ao arquivo, podemos fazer uso do 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(); } } 

Existem alguns pontos a serem observados:

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

Embora o OP não tenha pedido, mas apenas no caso de querermos procurar por linhas com alguma palavra-chave específica, por exemplo, confidential , podemos fazer uso de APIs de stream em Java:

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

Leitura e escrita de arquivos usando input 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"); } } } 

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

Vale a pena tentar para o Java 7+:

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

Parece promissor …

Para vários arquivos, você pode usar:

 static void out(String[] name, String[] content) { File path = new File(System.getProperty("user.dir") + File.separator + "OUT"); for (File file : path.listFiles()) if (!file.isDirectory()) file.delete(); path.mkdirs(); File c; for (int i = 0; i != name.length; i++) { c = new File(path + File.separator + name[i] + ".txt"); try { c.createNewFile(); FileWriter fiWi = new FileWriter(c.getAbsoluteFile()); BufferedWriter buWi = new BufferedWriter(fiWi); buWi.write(content[i]); buWi.close(); } catch (IOException e) { e.printStackTrace(); } } } 

Está funcionando muito bem.

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

Usando o 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 o 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 o 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 o 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 .

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

Você pode até mesmo criar um arquivo temporário usando uma propriedade do sistema , que será independente de qual sistema operacional você está usando.

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

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 arquivo fruits.txt no diretório raiz do projeto.

Lendo coleção com 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(); } } } 

A melhor maneira é usar o Java7: O Java 7 introduz uma nova maneira de trabalhar com o sistema de arquivos, junto com uma nova class de utilitário – Arquivos. Usando a class Files, podemos criar, mover, copiar, deletar arquivos e diretórios também; Ele 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); } 

Escrever com o FileChannel Se você está lidando com arquivos grandes, o FileChannel pode ser mais rápido que o IO padrão. O código a seguir escreve String para um arquivo usando 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 ver agora como podemos usar o FileOutputStream para gravar dados binários em um arquivo. O código a seguir converte uma string int bytes e grava os bytes em um 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(); } 

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

No Java 8, use Arquivos e Caminhos e use 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 } }