जावा में (टेक्स्ट) फ़ाइल बनाने और लिखने का सबसे सरल तरीका क्या है?
जावा में (टेक्स्ट) फ़ाइल बनाने और लिखने का सबसे सरल तरीका क्या है?
जवाबों:
ध्यान दें कि नीचे दिए गए प्रत्येक कोड नमूने फेंक सकते हैं IOException। कोशिश / पकड़ / अंत में संक्षिप्तता के लिए ब्लॉक छोड़ दिया गया है। देखें इस ट्यूटोरियल अपवाद संचालन के बारे में जानकारी के लिए।
ध्यान दें कि नीचे दिए गए कोड के प्रत्येक नमूने फ़ाइल को अधिलेखित कर देंगे यदि यह पहले से मौजूद है
एक पाठ फ़ाइल बनाना:
PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8");
writer.println("The first line");
writer.println("The second line");
writer.close();
एक बाइनरी फ़ाइल बनाना:
byte data[] = ...
FileOutputStream out = new FileOutputStream("the-file-name");
out.write(data);
out.close();
जावा 7+ उपयोगकर्ता Filesफ़ाइलों को लिखने के लिए कक्षा का उपयोग कर सकते हैं :
एक पाठ फ़ाइल बनाना:
List<String> lines = Arrays.asList("The first line", "The second line");
Path file = Paths.get("the-file-name.txt");
Files.write(file, lines, StandardCharsets.UTF_8);
//Files.write(file, lines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);
एक बाइनरी फ़ाइल बनाना:
byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);
"PrintWriter prints formatted representations of objects to a text-output stream. "बोहो का जवाब अधिक सही है, हालांकि यह बोझिल दिखता है (आप इसे हमेशा किसी उपयोगिता विधि में लपेट सकते हैं)।
writer.close()आखिरकार ब्लॉक में होना चाहिए
जावा 7 और ऊपर में:
try (Writer writer = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream("filename.txt"), "utf-8"))) {
writer.write("something");
}
हालांकि इसके लिए उपयोगी उपयोगिताओं हैं:
ध्यान दें कि आप एक का उपयोग कर सकते हैं FileWriter, लेकिन यह डिफ़ॉल्ट एन्कोडिंग का उपयोग करता है, जो अक्सर एक बुरा विचार है - एन्कोडिंग को स्पष्ट रूप से निर्दिष्ट करना सबसे अच्छा है।
नीचे मूल, पूर्व-से-जावा 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*/}
}इन्हें भी देखें: पढ़ना, लिखना और फ़ाइलें बनाना (NIO2 शामिल हैं)।
close()किसी भी धारा को किसी अन्य के चारों ओर लपेटने पर कॉल करने से सभी आंतरिक धाराएँ भी बंद हो जाएंगी।
यदि आपके पास पहले से ही वह सामग्री है जिसे आप फ़ाइल में लिखना चाहते हैं (और मक्खी पर उत्पन्न नहीं होता है), तो java.nio.file.Filesमूल I / O के हिस्से के रूप में जावा 7 में जोड़ आपके लक्ष्यों को प्राप्त करने का सबसे सरल और सबसे कुशल तरीका प्रदान करता है।
मूल रूप से एक फ़ाइल बनाने और लिखने के लिए केवल एक लाइन है, एक सरल विधि कॉल !
निम्न उदाहरण बनाता है और यह प्रदर्शित करने के लिए 6 विभिन्न फ़ाइलों को लिखता है कि इसका उपयोग कैसे किया जा सकता है:
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();
}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();
}
}
}
}output.close()IOException
फ़ाइल बनाने या ओवरराइट करने के लिए यहां एक छोटा सा उदाहरण कार्यक्रम है। यह लंबा संस्करण है इसलिए इसे अधिक आसानी से समझा जा सकता है।
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();
}
}जावा में फ़ाइल बनाने और लिखने का एक बहुत ही सरल तरीका:
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);
}
}
}File.exists()/createNewFile()कोड व्यर्थ और बेकार दोनों है। ऑपरेटिंग सिस्टम को पहले से ही ठीक वैसा ही काम करना होता है जब new FileWriter()इसे बनाया जाता है। आप यह सब दो बार होने के लिए मजबूर कर रहे हैं।
FileWriterनिम्न प्रकार से new FileWriter(file.getAbsoluteFile(),true)
उपयोग:
try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) {
writer.write("text to write");
}
catch (IOException ex) {
// Handle me
} उपयोग करने try()से स्वचालित रूप से स्ट्रीम बंद हो जाएगी। यह संस्करण छोटा, तेज़ (बफर) है और एन्कोडिंग चुनने में सक्षम बनाता है।
यह फीचर जावा 7 में पेश किया गया था।
StandardCharsets.UTF_8"Utf-8" स्ट्रिंग के बजाय "स्थिर" का उपयोग कर सकता है (यह टाइपो दोष से बचाता है) ...new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8)...- java.nio.charset.StandardCharsetsजावा 7 में प्रस्तुत किया गया है
यहां हम एक टेक्स्ट फाइल में एक स्ट्रिंग दर्ज कर रहे हैं:
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हम आसानी से एक नई फ़ाइल बना सकते हैं और उसमें सामग्री जोड़ सकते हैं।
चूंकि लेखक ने निर्दिष्ट नहीं किया है कि क्या उन्हें जावा संस्करणों के लिए एक समाधान की आवश्यकता है जो कि ईओएलएएलडी (सूर्य और आईबीएम दोनों द्वारा किया गया है, और ये तकनीकी रूप से सबसे व्यापक जेवीएम हैं), और इस तथ्य के कारण कि अधिकांश लोग उत्तर देने के लिए प्रतीत होते हैं लेखक का प्रश्न यह निर्दिष्ट करने से पहले कि यह एक पाठ (गैर-बाइनरी) फ़ाइल है, मैंने अपना उत्तर देने का निर्णय लिया है।
सबसे पहले, जावा 6 आम तौर पर जीवन के अंत तक पहुंच गया है, और चूंकि लेखक ने निर्दिष्ट नहीं किया है कि उसे विरासत संगतता की आवश्यकता है, मुझे लगता है कि इसका स्वचालित रूप से जावा 7 या उससे ऊपर का मतलब है (Java 7 अभी तक आईबीएम द्वारा EoL'd नहीं है)। इसलिए, हम फ़ाइल I / O ट्यूटोरियल में सही देख सकते हैं: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html
जावा एसई 7 रिलीज़ से पहले, java.io.File क्लास फ़ाइल I / O के लिए उपयोग किया जाने वाला तंत्र था, लेकिन इसमें कई कमियां थीं।
- जब वे असफल हुए तो कई विधियाँ अपवाद नहीं थी, इसलिए एक उपयोगी त्रुटि संदेश प्राप्त करना असंभव था। उदाहरण के लिए, यदि कोई फ़ाइल विलोपन विफल हो गया, तो प्रोग्राम को एक "डिलीट फ़ेल" प्राप्त होगा, लेकिन यह नहीं पता होगा कि क्या ऐसा इसलिए था क्योंकि फ़ाइल मौजूद नहीं थी, उपयोगकर्ता के पास अनुमतियां नहीं थीं, या कोई अन्य समस्या थी।
- नाम बदलने की विधि लगातार प्लेटफार्मों भर में काम नहीं किया।
- प्रतीकात्मक लिंक के लिए कोई वास्तविक समर्थन नहीं था।
- मेटाडेटा के लिए अधिक समर्थन वांछित था, जैसे फ़ाइल अनुमतियां, फ़ाइल स्वामी और अन्य सुरक्षा विशेषताएँ। फ़ाइल मेटाडेटा एक्सेस करना अक्षम था।
- फ़ाइल विधियों के कई पैमाने नहीं थे। सर्वर पर एक बड़ी निर्देशिका लिस्टिंग का अनुरोध करने से परिणाम लटका हुआ हो सकता है। बड़ी निर्देशिकाएं भी स्मृति संसाधन समस्याओं का कारण बन सकती हैं, जिसके परिणामस्वरूप सेवा से वंचित होना पड़ता है।
- विश्वसनीय कोड लिखना संभव नहीं था, जो किसी फ़ाइल ट्री पर फिर से चल सके और उचित रूप से प्रतिक्रिया दे सके यदि परिपत्र प्रतीकात्मक लिंक थे।
ओह ठीक है, कि java.io.File बाहर नियम। यदि कोई फ़ाइल लिखी / संलग्न नहीं की जा सकती है, तो आप यह भी नहीं जान सकते हैं कि क्यों।
हम ट्यूटोरियल देखना जारी रख सकते हैं: https://docs.oracle.com/javase/tutorial/essential/io/file.html# असामान्य
यदि आपके पास सभी पंक्तियाँ हैं जो आप पहले से पाठ फ़ाइल में लिखेंगे (परिशिष्ट) , अनुशंसित दृष्टिकोण https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# है लिखने-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption ...-
यहाँ एक उदाहरण (सरलीकृत) है:
Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, StandardCharsets.UTF_8);एक और उदाहरण (परिशिष्ट):
Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);यदि आप जाने के रूप में फ़ाइल सामग्री लिखना चाहते हैं : 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 ...-
सरलीकृत उदाहरण (जावा 8 या ऊपर):
Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
writer.append("Zero header: ").append('0').write("\r\n");
[...]
}एक और उदाहरण (परिशिष्ट):
Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) {
writer.write("----------");
[...]
}इन तरीकों को लेखक के हिस्से पर कम से कम प्रयास की आवश्यकता होती है और इसे [पाठ] फाइलों को लिखते समय अन्य सभी को पसंद किया जाना चाहिए।
FileNotFoundExceptionऑपरेशन विफल होने पर उस पाठ से क्यों फेंक दिया जाता है।
यदि आप अपेक्षाकृत दर्द-रहित अनुभव करना चाहते हैं, तो आप Apache Commons IO पैकेज पर भी नज़र डाल सकते हैं , विशेष रूप से FileUtilsवर्ग ।
तीसरे पक्ष के पुस्तकालयों की जांच करना कभी न भूलें। दिनांक हेरफेर के लिए जोडा-टाइम , आम स्ट्रिंग ऑपरेशन के लिए अपाचे कॉमन्स लैंगStringUtils और इस तरह से आपके कोड को अधिक पठनीय बनाया जा सकता है।
जावा एक महान भाषा है, लेकिन मानक पुस्तकालय कभी-कभी थोड़ा निम्न-स्तर का होता है। फिर भी शक्तिशाली, लेकिन निम्न स्तर का।
FileUtilsहै static void write(File file, CharSequence data)। उदाहरण उपयोग: import org.apache.commons.io.FileUtils; FileUtils.write(new File("example.txt"), "string with data");। FileUtilsभी है writeLines, जो Collectionलाइनों की एक लेता है ।
यदि आप किसी कारण से बनाने और लिखने के कार्य को अलग करना चाहते हैं, तो जावा बराबर touchहै
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()एक अस्तित्व की जाँच करता है और फ़ाइल परमाणु बनाता है। यह उपयोगी हो सकता है यदि आप यह सुनिश्चित करना चाहते हैं कि आप इसे लिखने से पहले फ़ाइल के निर्माता थे, उदाहरण के लिए।
touchसामान्य अर्थों में नहीं था , बल्कि इसके सामान्य माध्यमिक उपयोग में डेटा को लिखे बिना फाइल बनाने के लिए था। स्पर्श का प्रलेखित उद्देश्य फ़ाइल पर टाइमस्टैम्प को अद्यतन करना है। यदि यह मौजूद नहीं है तो फ़ाइल बनाना वास्तव में दुष्प्रभाव है, और इसे एक स्विच के साथ अक्षम किया जा सकता है।
exists()/createNewFile()क्रम वस्तुतः समय और स्थान की बर्बादी हैं।
जावा में फ़ाइल बनाने और लिखने के कुछ संभावित तरीके यहां दिए गए हैं:
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();
}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();
}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();
}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();
}जावा में फ़ाइलों को पढ़ने और लिखने के तरीके के बारे में आगे इस ट्यूटोरियल की जाँच करें ।
FileWriterया OutputStreamWriterअंत में बंद नहीं होना चाहिए ?
उपयोग:
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);
}जावा 7 का उपयोग करने का सबसे अच्छा तरीका है: जावा 7 फाइल सिस्टम के साथ काम करने का एक नया तरीका पेश करता है, साथ ही एक नया उपयोगिता वर्ग - फाइलें। फ़ाइलें वर्ग का उपयोग करके, हम फ़ाइलों और निर्देशिकाओं को भी बना सकते हैं, स्थानांतरित कर सकते हैं, कॉपी कर सकते हैं; इसका उपयोग किसी फ़ाइल को पढ़ने और लिखने के लिए भी किया जा सकता है।
public void saveDataInFile(String data) throws IOException {
Path path = Paths.get(fileName);
byte[] strToBytes = data.getBytes();
Files.write(path, strToBytes);
}FileChannel के साथ लिखें यदि आप बड़ी फ़ाइलों के साथ काम कर रहे हैं, तो FileChannel मानक IO से अधिक तेज़ हो सकता है। निम्न कोड 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();
}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();
}FileOutputStream के साथ लिखें
आइए अब देखें कि हम फाइल में बाइनरी डेटा लिखने के लिए FileOutputStream का उपयोग कैसे कर सकते हैं। निम्न कोड एक स्ट्रिंग int बाइट्स को कनवर्ट करता है और एक FileOutputStream का उपयोग करके फ़ाइल को बाइट्स लिखता है:
public void saveDataInFile(String data) throws IOException {
FileOutputStream outputStream = new FileOutputStream(fileName);
byte[] strToBytes = data.getBytes();
outputStream.write(strToBytes);
outputStream.close();
}PrintWriter के साथ लिखें हम किसी फ़ाइल में स्वरूपित पाठ लिखने के लिए PrintWriter का उपयोग कर सकते हैं:
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();
}बफ़रड्राइवर के साथ लिखें: एक नई फ़ाइल के लिए स्ट्रिंग लिखने के लिए बफ़रड्राइवर का उपयोग करें:
public void saveDataInFile(String data) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
writer.write(data);
writer.close();
}मौजूदा फ़ाइल में स्ट्रिंग जोड़ें:
public void saveDataInFile(String data) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
writer.append(' ');
writer.append(data);
writer.close();
}मौजूदा फ़ाइल को अधिलेखित किए बिना फ़ाइल बनाने के लिए:
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
}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();
}
}
}exists()/createNewFile()क्रम वस्तुतः समय और स्थान की बर्बादी हैं।
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");
}
}exists()/createNewFile()क्रम वस्तुतः समय और स्थान की बर्बादी हैं।
केवल एक लाइन!
pathऔर lineस्ट्रिंग्स हैं
import java.nio.file.Files;
import java.nio.file.Paths;
Files.write(Paths.get(path), lines.getBytes());lines। यदि यह एक है java.lang.String, तो कॉलिंग प्लेटफ़ॉर्म डिफ़ॉल्ट एन्कोडिंग getBytes()का उपयोग करके बाइट्स का उत्पादन करेगी , जो सामान्य मामले में बहुत अच्छा नहीं है।
यदि हम जावा 7 और उसके बाद के संस्करण का उपयोग कर रहे हैं और यह भी जानते हैं कि फाइल में जोड़ी जाने वाली सामग्री (जोड़ा) तो हम NIO पैकेज में newBufferedWriter विधि का उपयोग कर सकते हैं ।
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();
}
}नोट करने के लिए कुछ बिंदु हैं:
StandardCharsets।try-with-resourceकथन का उपयोग करता है जिसमें प्रयास के बाद संसाधन स्वतः बंद हो जाते हैं।हालांकि ओपी ने नहीं पूछा है, लेकिन अगर हम कुछ विशिष्ट कीवर्ड वाली लाइनों की खोज करना चाहते हैं जैसे कि confidentialहम जावा में स्ट्रीम एपीआई का उपयोग कर सकते हैं:
//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();
}इनपुट और आउटपुटस्ट्रीम का उपयोग करके फाइल पढ़ना और लिखना:
//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");
}
}
}बस इस पैकेज को शामिल करें:
java.nio.fileऔर फिर आप फ़ाइल लिखने के लिए इस कोड का उपयोग कर सकते हैं:
Path file = ...;
byte[] buf = ...;
Files.write(file, buf);जावा 8 में फाइल्स और पाथ्स का उपयोग करें और कोशिश-के साथ-साथ रिसोर्स का उपयोग करें।
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
}
}कुछ सरल तरीके हैं, जैसे:
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();bwअप्रयुक्त है।
आप सिस्टम सिस्टम का उपयोग करके एक अस्थायी फ़ाइल भी बना सकते हैं , जो स्वतंत्र होगा कि आप किस ओएस का उपयोग कर रहे हैं।
File file = new File(System.*getProperty*("java.io.tmpdir") +
System.*getProperty*("file.separator") +
"YourFileName.txt");Google की अमरूद लाइब्रेरी का उपयोग करके, हम बहुत आसानी से एक फ़ाइल बना और लिख सकते हैं।
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);
}
}उदाहरण fruits.txtप्रोजेक्ट रूट डायरेक्टरी में एक नई फ़ाइल बनाता है ।
ग्राहकों के साथ संग्रह पढ़ना और फाइल को सहेजना, 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();
}
}
}फ़ाइल बनाने और उसे लिखने के कम से कम कई तरीके हैं:
छोटी फाइलें (1.7)
आप बाइट्स, या लाइन्स को लिखने की किसी एक विधि का उपयोग किसी फ़ाइल में कर सकते हैं।
Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".;
Files.write(file, buf);ये विधियाँ आपके लिए अधिकांश कार्यों का ध्यान रखती हैं, जैसे कि स्ट्रीम को खोलना और बंद करना, लेकिन बड़ी फ़ाइलों को संभालने के लिए अभिप्रेत नहीं हैं।
बफर स्ट्रीम I / O (1.7) का उपयोग करके बड़ी फ़ाइल लिखना
java.nio.fileपैकेज का समर्थन करता है चैनल मैं / हे, जो चलता रहता है बफ़र्स में डेटा, परतों में से कुछ है कि टोंटी कर सकते हैं मैं धारा / ओ को दरकिनार।
String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
writer.write(s, 0, s.length());
}विशेष रूप से लेखन कार्यों की एक बड़ी मात्रा को पूरा करते समय यह प्रदर्शन अपने कुशल प्रदर्शन के कारण तरजीही है। बफ़र किए गए प्रचालनों का यह प्रभाव होता है क्योंकि उन्हें ऑपरेटिंग सिस्टम के लिखने की विधि को हर एक बाइट के लिए महंगा आई / ओ संचालन पर कम करने की आवश्यकता नहीं होती है।
कॉपी करने के लिए NIO API का उपयोग (और एक नया बनाने के लिए) एक आउटपुटस्ट्रीम (1.7) के साथ एक फ़ाइल
Path oldFile = Paths.get("existing-file-path");
Path newFile = Paths.get("new-file-path");
try (OutputStream os = new FileOutputStream(newFile.toFile())) {
Files.copy(oldFile, os);
}अतिरिक्त तरीके भी हैं जो इनपुट से स्ट्रीम तक सभी बाइट्स को एक फ़ाइल में कॉपी करने की अनुमति देते हैं।
FileWriter (पाठ) (<1.7)
सीधे फ़ाइल (कम प्रदर्शन) में लिखता है और इसका उपयोग केवल तब किया जाना चाहिए जब लेखन की संख्या कम हो। किसी फ़ाइल में वर्ण-उन्मुख डेटा लिखने के लिए उपयोग किया जाता है।
String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();FileOutputStream (बाइनरी) (<1.7)
FileOutputStream कच्चे बाइट्स जैसे छवि डेटा की धाराओं को लिखने के लिए है।
byte data[] = "binary-to-write-to-file".getBytes();
FileOutputStream out = new FileOutputStream("file-name");
out.write(data);
out.close();इस दृष्टिकोण के साथ एक बार में एक बाइट लिखने के बजाय हमेशा बाइट्स की एक सरणी लिखने पर विचार करना चाहिए। स्पीडअप काफी महत्वपूर्ण हो सकता है - 10 x अधिक या अधिक। इसलिए write(byte[])जब भी संभव हो तरीकों का उपयोग करने की सिफारिश की जाती है।