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

En Java, tengo texto de un campo de texto en una variable String llamada “texto”.

¿Cómo puedo guardar el contenido de la variable “text” en un archivo?

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

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

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

 out.println(text); 

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

Si está utilizando Java 7 o posterior, puede usar la statement ” try-with-resources ” que automáticamente cerrará su PrintStream cuando haya terminado con esto (es decir, salga del bloque) así:

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

Todavía deberá lanzar explícitamente java.io.FileNotFoundException como antes.

Apache Commons IO contiene algunos excelentes métodos para hacerlo, 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 a un método:

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

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

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

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

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

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

Puede usar la modificación del código siguiente 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(); } } } 

Utilice Apache Commons IO api. Es sencillo

Use API como

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

Dependencia de Maven

  commons-io commons-io 2.4  

Prefiero confiar en las bibliotecas siempre que sea posible para este tipo de operaciones. Esto me hace menos probable que accidentalmente omita un paso importante (como el error de los wolfsnipes hecho anteriormente). Algunas bibliotecas se sugieren arriba, pero mi favorito para este tipo de cosas es Google Guava . Guava tiene una clase llamada Files que funciona muy 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 } 

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

Puede insertar este método en sus 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 forma, deberá importar java.io. * para que funcione; de ​​lo contrario, File, FileWriter y BufferedWriter no serán reconocidos.

Use esto, es muy legible:

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

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

Usando Java 7 :

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

Usando org.apache.commons.io.FileUtils:

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

Si solo le importa insertar un bloque de texto en un archivo, esto lo sobreescribirá 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 permite al usuario seleccionar un archivo usando un selector de archivos.

Es mejor cerrar el escritor / outputtream en un bloque finally, en caso de que ocurra algo

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

Puede usar ArrayList para poner todo el contenido de TextArea, por ejemplo, y enviarlo como parámetro llamando al guardado, ya que el escritor solo escribió líneas de cuerda, luego usamos el “para” línea por línea para escribir nuestro ArrayList al final estaremos contentos TextArea en el archivo txt. si algo no tiene sentido, lo siento es 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 privado SaveActionPerformed (java.awt.event.ActionEvent evt) {

 String NameFile = Name.getText(); ArrayList< String > Text = new ArrayList< String >(); Text.add(TextArea.getText()); SaveFile(NameFile, Text); 

}


public void SaveFile (String name, ArrayList 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); 

}

Creo que la mejor manera es usar Files.write(Path path, Iterable lines, OpenOption... options) :

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

Ver javadoc :

Escribe líneas de texto en un archivo. Cada línea es una secuencia char y se escribe en el archivo en secuencia con cada línea terminada por el separador de línea de la plataforma, tal como se define en la propiedad de la línea line.separator. Los caracteres están codificados en bytes utilizando el juego de caracteres especificado.

El parámetro de opciones especifica cómo se crea o abre el archivo. Si no hay opciones presentes, entonces este método funciona como si las opciones CREATE, TRUNCATE_EXISTING y WRITE estuvieran presentes. En otras palabras, abre el archivo para escritura, creando el archivo si no existe o truncar inicialmente un archivo regular existente a un tamaño de 0. El método asegura que el archivo se cierra cuando se escribieron 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 Files.write incorporado 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 of CharSequence (es decir, String), en lugar de un byte[] array, así text.getBytes() no es obligatorio, creo que es un poco más limpio.

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