În Java, am textul dintr-un câmp de text într-un Șir de variabile numite "text".
Cum pot salva conținutul "text" variabilă de la un fișier?
Daca're pur și simplu scoate de text, mai degrabă decât orice date binare, următoarele vor lucra:
PrintWriter out = new PrintWriter("filename.txt");
Apoi, scrie Șirul de la acesta, la fel ca la orice flux de ieșire:
out.println(text);
Te'll nevoie de excepție de manipulare, ca niciodată. Fi sigur de a chema afară.close()` când'am terminat de scris.
Dacă utilizați Java 7 sau o versiune ulterioară, puteți utiliza "try-with-resurse declarație" care va închide automat `PrintStream când ați terminat cu ea (ie ieșire bloc) astfel:
try (PrintWriter out = new PrintWriter("filename.txt")) {
out.println(text);
}
Va trebui în continuare să în mod explicit arunca java.io.FileNotFoundException
ca înainte.
Apache Commons IO conține câteva metode pentru a face acest lucru, în special Articolul conține următoarea metodă:
static void writeStringToFile(File file, String data)
care vă permite să scrie un text într-un fișier într-un singur apel de metodă:
FileUtils.writeStringToFile(new File("test.txt"), "Hello File");
De asemenea, poate doriți să ia în considerare specificarea codificarea fișierului, precum și.
Aruncati o privire la Fișier Java API
un exemplu rapid:
try (PrintStream out = new PrintStream(new FileOutputStream("filename.txt"))) {
out.print(text);
}
Tocmai ai făcut ceva similar în proiectul meu. Folosi FileWriter va simplifica o parte din munca ta. Și aici puteți găsi frumos 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)
{
}
}
În Java 7, puteți face acest lucru:
String content = "Hello File!";
String path = "C:/a.txt";
Files.write( Paths.get(path), content.getBytes());
Există mai multe info aici: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403
Folosesc FileUtils.writeStringToFile()` la Apache Commons IO. Nu este nevoie să reinventăm această roată specială.
Puteți utiliza modifica codul de mai jos pentru a scrie fișierul dvs. din orice clasă sau funcție este manipularea textului. Ne întrebăm totuși de ce lumea are nevoie de un nou editor de text...
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();
}
}
}
În Java 11 a `java.nio.fișierul.Fișierele
clasa a fost extinsă cu două noi metode de utilitate pentru a scrie un șir de caractere într-un fișier. Prima metodă (a se vedea JavaDoc aici) utilizează setul de caractere UTF-8 în mod implicit:
Files.writeString(Path.of("my", "path"), "My String");
Și cea de-a doua metodă (a se vedea JavaDoc aici) vă permite să specificați un individ charset:
Files.writeString(Path.of("my", "path"), "My String", StandardCharset.ISO_8859_1);
Ambele metode au un opțional Varargs parametru pentru setarea fișier de manipulare opțiuni (a se vedea JavaDoc aici). Următorul exemplu ar crea un non-existent de fișiere sau adăugare șir la unul deja existent:
Files.writeString(Path.of("my", "path"), "String to append", StandardOpenOption.CREATE, StandardOpenOption.APPEND);
În cazul în care aveți nevoie de a crea fișier text bazat pe un singur șir:
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();
}
}
}
Folosesc Apache Commons IO api. Sale simple
Utilizarea API ca
FileUtils.writeStringToFile(new File("FileNameToWrite.txt"), "stringToWrite");
Maven Dependență
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
Prefer să mă bazez pe biblioteci ori de câte ori este posibil pentru o astfel de operațiune. Asta mă face mai puțin susceptibile de a omite accidental un pas important (cum ar fi greseala wolfsnipes de mai sus). Unele biblioteci sunt sugerate mai sus, dar favoritul meu pentru acest tip de lucru este Google Guava. Guava are o clasa numita Fișiere, care funcționează bine pentru această sarcină:
// 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
}
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
Puteți introduce această metodă în clase. Dacă utilizați această metodă într-o clasă cu o metodă principală, schimba această clasă statice prin adăugarea la cuvântul cheie static. Oricum veți avea nevoie pentru a import java.io.* pentru a face să funcționeze altfel Fișier, FileWriter și BufferedWriter nu vor fi recunoscute.
Folosind 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);
}
Ai putea face acest lucru:
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 ;
}
};
Dacă îți pasă doar împingând un bloc de text în fișier, acesta va suprascrie-l de fiecare dată.
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
}
}
}
Acest exemplu permite utilizatorului pentru a selecta un fișier folosind un selector de fișier.
L's mai bine pentru a închide scriitor/outputstream în cele din urmă într-un bloc, doar în cazul în care ceva se întâmplă
finally{
if(writer != null){
try{
writer.flush();
writer.close();
}
catch(IOException ioe){
ioe.printStackTrace();
}
}
}
private static void generateFile(String stringToWrite, String outputFile) {
try {
FileWriter writer = new FileWriter(outputFile);
writer.append(stringToWrite);
writer.flush();
writer.close();
log.debug("New File is generated ==>"+outputFile);
} catch (Exception exp) {
log.error("Exception in generateFile ", exp);
}
}
Cred că cel mai bun mod este folosind Fișierele.scrie(Calea calea, Iterable<? se extinde CharSequence> linii, OpenOption... opțiuni)`:
String text = "content";
Path path = Paths.get("path", "to", "file");
Files.write(path, Arrays.asList(text));
Vezi javadoc:
Scrie linii de text într-un fișier. Fiecare linie este un char secvență și este scrise în fișier în ordine cu fiecare linie reziliat de către platform's linie de separare, astfel cum sunt definite de sistemul de proprietate linie.separator. Caracterele sunt codificate în bytes folosind specificate charset.
opțiuni parametru specifică modul în care fișierul este creat sau deschis. Dacă opțiunile nu sunt prezente, atunci această metodă funcționează ca în cazul în care CREAȚI, TRUNCATE_EXISTING, și SCRIE opțiuni sunt prezente. Cu alte cuvinte, deschide fișierul pentru scriere, crearea fișierului, dacă nu't există, sau inițial trunchierea unui regulate existente-fișier cu o dimensiune de 0. La metoda asigură că fișierul este închis atunci când toate liniile au fost scris (sau o eroare I/O sau alte runtime excepție este aruncat). Dacă o I/O eroare apare atunci poate să o facă după ce fișierul a fost creat sau trunchiat, sau după unele bytes au fost scrise la dosar.
Vă rugăm să rețineți. Văd oameni au răspuns deja cu Java's built-in Files.scrie, dar ce's special în răspunsul meu, pe care nimeni nu pare să-l menționez este supraîncărcat versiune de metoda care are un Iterable de CharSequence (de exemplu, String), în loc de un byte[]
matrice, astfel text.getBytes()
nu este necesară, care este un pic mai curat, cred.