separado - ¿Cómo guardo una cadena en un archivo de texto usando Java?

leer un archivo de texto separado por comas en java

Question

En Java, tengo texto de un campo de texto en una variable de cadena llamada "texto".

¿Cómo puedo guardar el contenido de la variable "texto" en un archivo?

Answer 1

Acabo de hacer algo parecido en mi proyecto. Usar FileWriter simplificará parte de su trabajo. Y aquí puedes encontrar buen 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)
    {
    }
}

Answer 2

Creo que la mejor manera es 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));

Ver javadoc :

Escribir líneas de texto en un archivo. Cada línea es una secuencia de caracteres y se escribe en el archivo en secuencia con cada línea terminada por el separador de líneas de la plataforma, tal como lo define la propiedad line.separator del sistema. Los caracteres se codifican en bytes utilizando el conjunto de caracteres especificado.

El parámetro de opciones especifica cómo se crea o abre el archivo. Si no hay opciones, este método funciona como si las opciones CREATE, TRUNCATE_EXISTING y WRITE estén presentes. En otras palabras, abre el archivo para escribir, crear el archivo si no existe o, inicialmente, truncar un archivo regular existente a un tamaño de 0. El método garantiza que el archivo se cierre cuando se hayan escrito todas las líneas ( o se produce un error de E / S u otra excepción de tiempo de ejecución). Si se produce un error de E / S, puede hacerlo después de que el archivo se haya creado o truncado, o después de que se hayan escrito algunos bytes en el archivo.

Tenga en cuenta. Veo que la gente ya ha respondido con los Files.write integrados de Files.write , pero lo que es especial en mi respuesta que nadie parece mencionar es la versión sobrecargada del método que toma un Iterable de CharSequence (es decir, String), en lugar de un byte[] array, por lo tanto, no se requiere text.getBytes() , que es un poco más limpio, creo.

Answer 3

Echa un vistazo a la API de archivos de Java

un ejemplo rápido:

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

Answer 4

En Java 7 puedes hacer esto:

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

Hay más información aquí: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

Answer 5

En caso de que necesite crear un archivo de texto basado en una sola cadena:

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

Answer 6

Es mejor cerrar la secuencia de escritura / salida en un bloque finalmente, en caso de que suceda algo

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

Answer 7

Podrías hacer esto:

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

Answer 8

Prefiero confiar en las bibliotecas siempre que sea posible para este tipo de operación. Esto hace que sea menos probable que omita accidentalmente un paso importante (como el error wolfsnipes cometido anteriormente). Algunas bibliotecas se sugieren arriba, pero mi favorita para este tipo de cosas es Google Guava . Guava tiene una clase llamada Files que funciona bien para esta tarea:

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

Answer 9

Puede usar ArrayList para poner todo el contenido de TextArea por ejemplo, y enviar como parámetro llamando al guardado, ya que el escritor acaba de escribir líneas de cadena, luego usamos la línea "por" línea por línea para escribir nuestra ArrayList al final. Estaremos contentos con TextArea en un archivo txt. Si algo no tiene sentido, lo siento es el traductor de google y yo que no hablo inglés.

Mire el Bloc de notas de Windows, no siempre salta líneas, y muestra todo en una línea, use Wordpad ok.

vacío vacío 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 (nombre de cadena, 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);        

}

Answer 10

Puede usar el código de modificación a continuación para escribir su archivo de cualquier clase o función que maneje el texto. Uno se pregunta por qué el mundo necesita un nuevo 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();
        }
    }
}

Answer 11

Si desea mantener los caracteres de retorno de carro de la cadena en un archivo, aquí hay un ejemplo 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);
        }

    });

Answer 12

Si simplemente está enviando texto, en lugar de datos binarios, lo siguiente funcionará:

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

Luego, escriba su Cadena en él, como lo haría en cualquier flujo de salida:

out.println(text);

Necesitarás un manejo excepcional, como siempre. Asegúrese de llamar a out.close() cuando haya terminado de escribir.

Si está utilizando Java 7 o posterior, puede usar la " declaración de prueba con recursos " que cerrará automáticamente su PrintStream cuando PrintStream (es decir, salga del bloque) de esta manera:

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

Aún deberá lanzar explícitamente la java.io.FileNotFoundException como antes.

Answer 13

Si solo te importa empujar un bloque de texto a un archivo, esto lo sobrescribirá 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 ejemplo le permite al usuario seleccionar un archivo usando un selector de archivos.

Answer 14

Usa esto, es muy legible:

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

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

Answer 15

Usando org.apache.commons.io.FileUtils:

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

Answer 16

Utilice FileUtils.writeStringToFile() de Apache Commons IO . No hay necesidad de reinventar esta rueda en particular.

Answer 17

Utilice Apache Commons IO api. Es sencillo

Usar API como

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

Dependencia de Maven

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

Answer 18

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

Answer 19

Apache Commons IO contiene algunos métodos excelentes para hacer esto, en particular, FileUtils contiene el siguiente método:

static void writeStringToFile(File file, String data) 

que le permite escribir texto en un archivo en una llamada de método:

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

También es posible que desee considerar la especificación de la codificación del archivo también.

Answer 20

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

Puedes insertar este método en tus clases. Si está utilizando este método en una clase con un método principal, cambie esta clase a estática agregando la palabra clave estática. De cualquier manera, deberá importar java.io. * para que funcione, de lo contrario, File, FileWriter y BufferedWriter no se reconocerán.