जावा में, मेरे पास एक पाठ फ़ील्ड से एक स्ट्रिंग चर है जिसे "पाठ" कहा जाता है।
मैं "टेक्स्ट" चर की सामग्री को किसी फ़ाइल में कैसे सहेज सकता हूं?
जावा में, मेरे पास एक पाठ फ़ील्ड से एक स्ट्रिंग चर है जिसे "पाठ" कहा जाता है।
मैं "टेक्स्ट" चर की सामग्री को किसी फ़ाइल में कैसे सहेज सकता हूं?
जवाबों:
यदि आप किसी बाइनरी डेटा के बजाय केवल टेक्स्ट आउटपुट कर रहे हैं, तो निम्न कार्य करेगा:
PrintWriter out = new PrintWriter("filename.txt");फिर, अपने स्ट्रिंग को इसे लिखें, जैसे आप किसी भी आउटपुट स्ट्रीम में करेंगे:
out.println(text);आपको हमेशा की तरह अपवाद से निपटने की आवश्यकता होगी। out.close()जब आप लिखना समाप्त कर लें, तो कॉल करना सुनिश्चित करें ।
यदि आप जावा 7 या उसके बाद का उपयोग कर रहे हैं, तो आप " ट्राय-विथ-रिसोर्स स्टेटमेंट " का उपयोग कर सकते हैं, जो आपके साथ PrintStreamहोने पर अपने आप बंद हो जाएगा (यानी ब्लॉक से बाहर निकलें) जैसे:
try (PrintWriter out = new PrintWriter("filename.txt")) {
out.println(text);
}
आपको java.io.FileNotFoundExceptionपहले की तरह स्पष्ट रूप से फेंकने की आवश्यकता होगी ।
Apache Commons IO में ऐसा करने के लिए कुछ बेहतरीन तरीके हैं, विशेष रूप से FileUtils में निम्न विधि है:
static void writeStringToFile(File file, String data) जो आपको एक विधि कॉल में किसी फ़ाइल में पाठ लिखने की अनुमति देता है:
FileUtils.writeStringToFile(new File("test.txt"), "Hello File");आप फ़ाइल के लिए एन्कोडिंग निर्दिष्ट करने पर भी विचार कर सकते हैं।
FileUtils.writeStringToFile(new File("test.txt"), "Hello File", forName("UTF-8"));
जावा फ़ाइल एपीआई पर एक नज़र डालें
एक त्वरित उदाहरण:
try (PrintStream out = new PrintStream(new FileOutputStream("filename.txt"))) {
out.print(text);
}
@Cleanup new FileOutputStream(...)और तुम काम कर रहे हो।
जावा 7 में आप यह कर सकते हैं:
String content = "Hello File!";
String path = "C:/a.txt";
Files.write( Paths.get(path), content.getBytes());
यहाँ अधिक जानकारी है: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403
content.getBytes(StandardCharsets.UTF_8)एन्कोडिंग को स्पष्ट रूप से परिभाषित करने के लिए इस्तेमाल किया जा सकता है।
बस मेरे प्रोजेक्ट में कुछ ऐसा ही हुआ। FileWriter का उपयोग करना आपकी नौकरी के भाग को सरल करेगा। और यहाँ आप अच्छा ट्यूटोरियल पा सकते हैं ।
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)
{
}
}.close()फेंक नहीं है (कम से कम जावा 7 में?), शायद आखिरी कोशिश है बेमानी?
throw new RuntimeException(e);
Apache Commons IOFileUtils.writeStringToFile() से उपयोग करें । इस विशेष पहिये को सुदृढ़ करने की आवश्यकता नहीं है।
जो भी क्लास या फंक्शन टेक्स्ट हैंडल कर रहा है, उससे अपनी फाइल लिखने के लिए आप नीचे दिए कोड को संशोधित कर सकते हैं। एक आश्चर्य है कि क्यों दुनिया एक नए पाठ संपादक की जरूरत है ...
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();
}
}
}में जावा 11java.nio.file.Files वर्ग दो नए उपयोगिता तरीके से बढ़ा दी गई एक फ़ाइल में एक स्ट्रिंग लिखने के लिए। पहली विधि (JavaDoc को यहां देखें ) डिफ़ॉल्ट रूप में charset UTF-8 का उपयोग करती है :
Files.writeString(Path.of("my", "path"), "My String");और दूसरी विधि (देखें JavaDoc यहाँ ) एक व्यक्तिगत चारसेट निर्दिष्ट करने की अनुमति देता है:
Files.writeString(Path.of("my", "path"), "My String", StandardCharset.ISO_8859_1);दोनों तरीकों में फाइल हैंडलिंग ऑप्शंस सेट करने के लिए एक वैकल्पिक वरार्स पैरामीटर है (देखें JavaDoc यहां )। निम्न उदाहरण एक गैर-मौजूदा फ़ाइल बनाएगा या स्ट्रिंग को मौजूदा एक के साथ जोड़ देगा:
Files.writeString(Path.of("my", "path"), "String to append", StandardOpenOption.CREATE, StandardOpenOption.APPEND);मैं इस तरह के ऑपरेशन के लिए जब भी संभव हो पुस्तकालयों पर भरोसा करना पसंद करता हूं। इससे मुझे गलती से एक महत्वपूर्ण कदम उठाने की संभावना कम हो जाती है (जैसे कि गलती से ऊपर किए गए भेड़ियों)। कुछ पुस्तकालयों के ऊपर सुझाव दिए गए हैं, लेकिन इस तरह की चीज़ों के लिए मेरा पसंदीदा Google अमरूद है । अमरूद में फाइल नामक एक वर्ग है जो इस कार्य के लिए अच्छी तरह से काम करता है:
// 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
}Charsets.UTF-8।
Charsets.UTF_8
Files.asCharSink(file, charset).write(text)
Apache Commons IO api का प्रयोग करें। यह आसान है
API का उपयोग करें
FileUtils.writeStringToFile(new File("FileNameToWrite.txt"), "stringToWrite");मावेन निर्भरता
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>यदि आपको किसी एक स्ट्रिंग के आधार पर पाठ फ़ाइल बनाने की आवश्यकता है तो:
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.nio.file.Files;
import java.nio.file.Paths;
Files.write(Paths.get(path), lines.getBytes(), StandardOpenOption.WRITE);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आप इस विधि को अपनी कक्षाओं में सम्मिलित कर सकते हैं। यदि आप मुख्य विधि वाली कक्षा में इस पद्धति का उपयोग कर रहे हैं, तो स्थिर कुंजी शब्द जोड़कर इस वर्ग को स्थैतिक में बदल दें। किसी भी तरह से आपको java.io को आयात करने की आवश्यकता होगी। * इसे काम करने के लिए अन्यथा फ़ाइल, फ़ाइलविटर और बफ़रड्राइवर को मान्यता नहीं दी जाएगी।
आप ऐसा कर सकते हैं:
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 ;
}
};का उपयोग कर 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);
}Files.write(targetPath, bytes);फिर फ़ाइल को अधिलेखित करने के लिए उपयोग करें। यह उम्मीद के मुताबिक काम करेगा।
Org.apache.commons.io.FileUtils का उपयोग करना:
FileUtils.writeStringToFile(new File("log.txt"), "my string", Charset.defaultCharset());यदि आप केवल पाठ के एक ब्लॉक को फाइल करने पर जोर देते हैं, तो यह हर बार इसे अधिलेखित कर देगा।
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
}
}
}यह उदाहरण उपयोगकर्ता को फ़ाइल चयनकर्ता का उपयोग करके फ़ाइल का चयन करने की अनुमति देता है।
लेखक / आउटपुटस्ट्रीम को अंततः ब्लॉक में बंद करना बेहतर है, बस कुछ होने की स्थिति में
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);
}}
मुझे लगता है कि सबसे अच्छा तरीका उपयोग कर रहा है 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));जावदोक देखें :
किसी फ़ाइल में पाठ की पंक्तियाँ लिखें। प्रत्येक लाइन एक चार्ट अनुक्रम है और प्लेटफ़ॉर्म के लाइन विभाजक द्वारा समाप्त की गई प्रत्येक पंक्ति के अनुक्रम में फ़ाइल में लिखा जाता है, जैसा कि सिस्टम प्रॉपर्टी लाइन द्वारा परिभाषित किया गया है। सेपरेटर। वर्ण निर्दिष्ट वर्णसेट का उपयोग करके बाइट्स में एन्कोड किए गए हैं।
विकल्प पैरामीटर निर्दिष्ट करता है कि फ़ाइल कैसे बनाई गई या खोली गई। यदि कोई विकल्प मौजूद नहीं है, तो यह विधि काम करती है जैसे कि CREATE, TRUNCATE_EXISTING, और WRITE विकल्प मौजूद हैं। दूसरे शब्दों में, यह लिखने के लिए फ़ाइल को खोलता है, अगर यह मौजूद नहीं है, तो फ़ाइल का निर्माण करना या किसी मौजूदा नियमित फ़ाइल को 0. के आकार में छोटा करना। विधि यह सुनिश्चित करती है कि फ़ाइल तब बंद हो जब सभी लाइनें लिखी गई हों ( या I / O त्रुटि या अन्य रनटाइम अपवाद को फेंक दिया गया है)। यदि I / O त्रुटि होती है, तो ऐसा फ़ाइल के निर्माण या छंटनी के बाद, या फ़ाइल पर कुछ बाइट्स लिखे जाने के बाद हो सकता है।
कृपया ध्यान दें। मैं देखता हूं कि लोगों ने जावा के बिल्ट-इन के साथ पहले ही जवाब दे दिया है Files.write, लेकिन मेरे जवाब में ऐसा क्या खास है, जिसका कोई उल्लेख नहीं करता है, यह विधि का ओवरलोड संस्करण है, जो एक byte[]सरणी के बजाय, इटरटेबल ऑफ चार्जसेंस (यानी स्ट्रिंग) लेता है , इस तरह text.getBytes()की आवश्यकता नहीं है , मुझे लगता है कि थोड़ा क्लीनर है।
यदि आप गाड़ी के रिटर्न कैरेक्टर को स्ट्रिंग से फाइल में रखना चाहते हैं तो एक कोड उदाहरण है:
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);
}
});मेरा तरीका सभी एंड्रॉइड संस्करणों पर चलने और URL / URI जैसे fecthing संसाधनों की जरूरतों के कारण स्ट्रीम पर आधारित है, किसी भी सुझाव का स्वागत है।
जहाँ तक संबंधित है, धाराएँ (InputStream और OutputStream) बाइनरी डेटा ट्रांसफर करती हैं, जब डेवलपर एक स्ट्रिंग को स्ट्रीम में लिखने के लिए जाता है, तो उसे पहले बाइट में बदलना होगा, या दूसरे शब्दों में उसे एनकोड करना होगा।
public boolean writeStringToFile(File file, String string, Charset charset) {
if (file == null) return false;
if (string == null) return false;
return writeBytesToFile(file, string.getBytes((charset == null) ? DEFAULT_CHARSET:charset));
}
public boolean writeBytesToFile(File file, byte[] data) {
if (file == null) return false;
if (data == null) return false;
FileOutputStream fos;
BufferedOutputStream bos;
try {
fos = new FileOutputStream(file);
bos = new BufferedOutputStream(fos);
bos.write(data, 0, data.length);
bos.flush();
bos.close();
fos.close();
} catch (IOException e) {
e.printStackTrace();
Logger.e("!!! IOException");
return false;
}
return true;
}आप ArrayList का उपयोग कर सकते हैं TextArea की सभी सामग्री को छूट के लिए, और सहेजें को कॉल करके पैरामीटर के रूप में भेजें, जैसा कि लेखक ने सिर्फ स्ट्रिंग लाइनें लिखी हैं, फिर हम अंत में अपने ArrayList को लिखने के लिए "लाइन" लाइन के लिए उपयोग करते हैं। हम txt फ़ाइल में TextArea की सामग्री होंगे। अगर कुछ समझ में नहीं आता है, तो मुझे खेद है कि Google अनुवादक है और मुझे अंग्रेजी नहीं आती है।
विंडोज नोटपैड देखें, यह हमेशा लाइनों को कूदता नहीं है, और सभी को एक लाइन में दिखाता है, वर्डपैड ओके का उपयोग करें।
private void 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< 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);
}
}