txt - ¿Cómo creo un archivo y lo escribo en Java?

modificar archivos txt en java

Question

¿Cuál es la forma más sencilla de crear y escribir en un archivo (texto) en Java?

Answer 1

Aquí estamos ingresando una cadena en un archivo 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 crear fácilmente un nuevo archivo y agregarle contenido.

Answer 2

Aquí hay un pequeño programa de ejemplo para crear o sobrescribir un archivo. Es la versión larga para que pueda entenderse más fácilmente.

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

Answer 3

Creando un archivo de muestra:

try {
    File file = new File ("c:/new-file.txt");
    if(file.createNewFile()) {
        System.out.println("Successful created!");
    }
    else {
        System.out.println("Failed to create!");
    }
}
catch (IOException e) {
    e.printStackTrace();
}

Answer 4

Creo que este es el camino más corto:

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

Answer 5

Dado que el autor no especificó si requieren una solución para las versiones de Java que han sido EoL''d (tanto por Sun como por IBM, y estas son las JVM técnicamente más extendidas), y debido al hecho de que la mayoría de las personas parecen haber respondido La pregunta del autor antes de que se especificara que es un archivo de texto (no binario) , he decidido proporcionar mi respuesta.

En primer lugar, Java 6 generalmente ha llegado al final de su vida útil y, como el autor no especificó que necesita compatibilidad heredada, supongo que significa automáticamente que Java 7 o superior (Java 7 aún no está a cargo de IBM). Entonces, podemos ver el tutorial de E / S del archivo: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Antes de la versión de Java SE 7, la clase java.io.File era el mecanismo utilizado para la E / S de archivos, pero tenía varios inconvenientes.

• Muchos métodos no lanzaron excepciones cuando fallaron, por lo que fue imposible obtener un mensaje de error útil. Por ejemplo, si fallara la eliminación del archivo, el programa recibiría un "error de eliminación" pero no sabría si era porque el archivo no existía, el usuario no tenía permisos o había algún otro problema.
• El método de cambio de nombre no funcionó de manera consistente en todas las plataformas.
• No hubo un apoyo real para los enlaces simbólicos.
• Se deseaba más compatibilidad con los metadatos, como permisos de archivo, propietario del archivo y otros atributos de seguridad. Acceder a los metadatos del archivo fue ineficiente.
• Muchos de los métodos de archivo no se escalaron. Solicitar una lista grande de directorios a través de un servidor podría resultar en un bloqueo. Los directorios grandes también pueden causar problemas de recursos de memoria, lo que resulta en una denegación de servicio.
• No fue posible escribir un código confiable que pudiera recorrer recursivamente un árbol de archivos y responder de manera apropiada si hubiera enlaces simbólicos circulares.

Oh bueno, eso descarta el archivo java.io. Si un archivo no se puede escribir / adjuntar, es posible que ni siquiera sepa por qué.

Podemos seguir viendo el tutorial: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Si tiene todas las líneas que escribirá (adjunte) al archivo de texto por adelantado , el enfoque recomendado es 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...-

Aquí hay un ejemplo (simplificado):

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

Otro ejemplo (adjuntar):

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

Si desea escribir el contenido del archivo a medida que avanza : 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...-

Ejemplo simplificado (Java 8 o superior):

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

Otro ejemplo (adjuntar):

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

Estos métodos requieren un esfuerzo mínimo por parte del autor y deben ser preferidos a todos los demás al escribir en archivos [de texto].

Answer 6

En Java 7 y superior:

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

Hay utilidades útiles para eso, sin embargo:

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

Tenga en cuenta también que puede usar un FileWriter , pero usa la codificación predeterminada, que a menudo es una mala idea; es mejor especificar la codificación explícitamente.

A continuación se muestra la respuesta original, anterior a 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*/}
}

Vea también: Leer, escribir y crear archivos (incluye NIO2).

Answer 7

En Java 8, use Archivos y rutas y use la construcción 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
    }
}

Answer 8

Estas son algunas de las formas posibles de crear y escribir un archivo en Java:

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

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

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

Utilizando 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 más información, consulte este tutorial sobre Cómo leer y escribir archivos en Java .

Answer 9

Hay algunas formas 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();

Answer 10

Incluso puede crear un archivo temporal utilizando una propiedad del sistema , que será independiente del sistema operativo que esté utilizando.

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

Answer 11

La forma más sencilla que puedo encontrar:

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

Probablemente solo funcionará para 1.7+.

Answer 12

Lectura y escritura de archivos usando input y outputstream:

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

Answer 13

Leyendo colección con clientes y guardando en archivo, con 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();
        }
    }
}

Answer 14

Para crear un archivo sin sobrescribir el archivo 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
}

Answer 15

Sólo una línea! path y line son cadenas

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

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

Answer 16

Si desea tener una experiencia relativamente libre de dolor, también puede echar un vistazo al paquete de Apache Commons IO , más específicamente a la clase FileUtils .

Nunca te olvides de consultar las bibliotecas de terceros. Joda-Time para la manipulación de fechas, Apache Commons Lang StringUtils para operaciones de cadenas comunes y tales pueden hacer que su código sea más legible.

Java es un gran lenguaje, pero la biblioteca estándar a veces es un poco de bajo nivel. Potente, pero de bajo nivel, no obstante.

Answer 17

Si por alguna razón desea separar el acto de crear y escribir, el equivalente de Java al touch es

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() realiza una comprobación de existencia y crea un archivo de forma atómica. Esto puede ser útil si quiere asegurarse de que fue el creador del archivo antes de escribirlo, por ejemplo.

Answer 18

Si utilizamos Java 7 y superior y también conocemos el contenido que debe agregarse (adjuntado) al archivo, podemos utilizar el método newBufferedWriter en el paquete 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();
    }
}

Hay algunos puntos a tener en cuenta:

1. Siempre es un buen hábito especificar la codificación de juegos de caracteres y para eso tenemos constantes en la clase StandardCharsets .
2. El código usa la declaración try-with-resource en la que los recursos se cierran automáticamente después del intento.

Aunque OP no lo ha solicitado, pero en caso de que queramos buscar líneas que tengan alguna palabra clave específica, por ejemplo, confidential , podemos utilizar API de flujo en 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();
}

Answer 19

Si ya tiene el contenido que desea escribir en el archivo (y no se genera sobre la marcha), la adición java.nio.file.Files en Java 7 como parte de la E / S nativa proporciona la forma más sencilla y eficiente de lograr tus metas.

Básicamente, crear y escribir en un archivo es solo de una línea, además de una simple llamada de método .

El siguiente ejemplo crea y escribe en 6 archivos diferentes para mostrar cómo se puede usar:

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

Answer 20

Solo incluye este paquete:

java.nio.file

Y luego puedes usar este código para escribir el archivo:

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

Answer 21

Una forma muy sencilla de crear y escribir en un archivo en 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);
        }
    }
}

Referencia: Archivo crear Ejemplo en java

Answer 22

Usando la biblioteca de guayabas de Google, podemos crear y escribir en un archivo muy fácilmente.

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

El ejemplo crea un nuevo archivo fruits.txt en el directorio raíz del proyecto.

Answer 23

Utilizar:

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

Answer 24

Utilizar:

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

El uso de try() cerrará la transmisión automáticamente. Esta versión es corta, rápida (almacenada en búfer) y permite elegir la codificación.

Esta característica fue introducida en Java 7.

Answer 25

Vale la pena intentarlo para Java 7+:

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

Parece prometedor ...

Answer 26

Tenga en cuenta que cada uno de los ejemplos de código a continuación puede IOException . Los bloques de prueba / captura / finalmente se han omitido por brevedad. Consulte este tutorial para obtener información sobre el manejo de excepciones.

Creación de un archivo de texto (tenga en cuenta que esto sobrescribirá el archivo si ya existe):

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

Creando un archivo binario (esto también sobrescribirá el archivo):

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

Los usuarios de Java 7+ pueden usar la clase Files para escribir en archivos:

Creando un archivo 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, Charset.forName("UTF-8"));
//Files.write(file, lines, Charset.forName("UTF-8"), StandardOpenOption.APPEND);

Creando un archivo binario:

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

Answer 27

La mejor manera es usar Java7: Java 7 presenta una nueva forma de trabajar con el sistema de archivos, junto con una nueva clase de utilidad: Archivos. Usando la clase de Archivos, podemos crear, mover, copiar, eliminar archivos y directorios también; También se puede utilizar para leer y escribir en un archivo.

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

    Files.write(path, strToBytes);
}

Escriba con FileChannel Si está tratando con archivos grandes, FileChannel puede ser más rápido que IO estándar. El siguiente código escribe Cadena en un archivo 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();
}

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

Escribir con FileOutputStream

Veamos ahora cómo podemos usar FileOutputStream para escribir datos binarios en un archivo. El siguiente código convierte un String int bytes y escribe los bytes en el archivo usando un FileOutputStream:

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

    outputStream.close();
}

Escribir con PrintWriter podemos usar un PrintWriter para escribir texto con formato en un archivo:

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

Escriba con BufferedWriter: use BufferedWriter para escribir una cadena en un archivo nuevo:

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

    writer.close();
}

anexar una cadena al archivo existente:

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

    writer.close();
}

Answer 28

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

Answer 29

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

Answer 30

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