วิธีที่ง่ายที่สุดในการสร้างและเขียนไฟล์ (ข้อความ) ใน Java คืออะไร
วิธีที่ง่ายที่สุดในการสร้างและเขียนไฟล์ (ข้อความ) ใน Java คืออะไร
คำตอบ:
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();
ผู้ใช้Java 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. "
คำตอบของ Bozho นั้นถูกต้องมากขึ้นแม้ว่ามันจะดูยุ่งยาก (คุณสามารถห่อมันด้วยวิธียูทิลิตี้ได้เสมอ)
writer.close()
ควรอยู่ในช่วงท้ายบล็อก
ใน Java 7 ขึ้นไป:
try (Writer writer = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream("filename.txt"), "utf-8"))) {
writer.write("something");
}
มีสาธารณูปโภคที่เป็นประโยชน์สำหรับการที่แม้ว่า:
โปรดทราบว่าคุณสามารถใช้ a FileWriter
แต่ใช้การเข้ารหัสเริ่มต้นซึ่งมักเป็นแนวคิดที่ไม่ดี - เป็นการดีที่สุดที่จะระบุการเข้ารหัสอย่างชัดเจน
ด้านล่างนี้เป็นคำตอบดั้งเดิมก่อนหน้า Java 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
เพิ่มใน Java 7 ซึ่งเป็นส่วนหนึ่งของ I / O ดั้งเดิมจะให้วิธีที่ง่ายและมีประสิทธิภาพที่สุดในการบรรลุเป้าหมายของคุณ
โดยทั่วไปการสร้างและการเขียนไฟล์เป็นหนึ่งบรรทัดเท่านั้นยิ่งไปกว่านั้นวิธีการเรียกง่าย ๆ !
ตัวอย่างต่อไปนี้สร้างและเขียนถึง 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();
}
}
วิธีง่ายๆในการสร้างและเขียนไฟล์ใน Java:
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()
จะปิดกระแสโดยอัตโนมัติ รุ่นนี้สั้นเร็ว (บัฟเฟอร์) และเปิดใช้งานการเลือกการเข้ารหัส
คุณลักษณะนี้ถูกนำมาใช้ใน Java 7
StandardCharsets.UTF_8
แทนสตริง "utf-8" (ซึ่งจะช่วยป้องกันข้อผิดพลาดจากการพิมพ์ผิด) ...new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8)...
- ได้java.nio.charset.StandardCharsets
รับการแนะนำใน java 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
เราสามารถสร้างไฟล์ใหม่และเพิ่มเนื้อหาลงไปได้อย่างง่ายดาย
เนื่องจากผู้เขียนไม่ได้ระบุว่าพวกเขาต้องการโซลูชันสำหรับ Java เวอร์ชันที่เป็น EoL หรือไม่ (โดยทั้ง Sun และ IBM และสิ่งเหล่านี้เป็นเทคนิคที่แพร่หลายมากที่สุด JVMs) และเนื่องจากข้อเท็จจริงที่ว่าคนส่วนใหญ่ดูเหมือนจะตอบ คำถามของผู้เขียนก่อนที่จะระบุว่ามันเป็นไฟล์ข้อความ (ไม่ใช่ไบนารี)ฉันได้ตัดสินใจที่จะให้คำตอบของฉัน
ก่อนอื่น Java 6 สิ้นสุดอายุการใช้งานโดยทั่วไปและเนื่องจากผู้เขียนไม่ได้ระบุว่าเขาต้องการความเข้ากันได้แบบดั้งเดิมฉันเดาว่าโดยอัตโนมัติหมายความว่า Java 7 หรือสูงกว่า (Java 7 ยังไม่ได้เป็น EoL โดย IBM) ดังนั้นเราสามารถดูได้ที่ไฟล์ I / O บทช่วยสอน: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html
ก่อนการเปิดตัว Java SE 7 คลาส java.io.File เป็นกลไกที่ใช้สำหรับไฟล์ I / O แต่มีข้อเสียหลายประการ
- วิธีการมากมายไม่ส่งข้อยกเว้นเมื่อล้มเหลวดังนั้นจึงเป็นไปไม่ได้ที่จะได้รับข้อความแสดงข้อผิดพลาดที่เป็นประโยชน์ ตัวอย่างเช่นหากการลบไฟล์ล้มเหลวโปรแกรมจะได้รับ "การลบล้มเหลว" แต่ไม่ทราบว่าเป็นเพราะไฟล์ไม่มีอยู่หรือไม่ผู้ใช้ไม่มีสิทธิ์หรือมีปัญหาอื่น ๆ
- วิธีการเปลี่ยนชื่อไม่ทำงานอย่างสม่ำเสมอในแพลตฟอร์มต่างๆ
- ไม่มีการสนับสนุนที่แท้จริงสำหรับลิงก์สัญลักษณ์
- ต้องการการสนับสนุนเพิ่มเติมสำหรับข้อมูลเมตาเช่นสิทธิ์ของไฟล์เจ้าของไฟล์และคุณลักษณะความปลอดภัยอื่น ๆ การเข้าถึงข้อมูลเมตาของไฟล์ไม่มีประสิทธิภาพ
- วิธีการหลายไฟล์ไม่ได้ปรับขนาด การร้องขอรายชื่อไดเรกทอรีขนาดใหญ่บนเซิร์ฟเวอร์อาจทำให้แฮงค์ ไดเรกทอรีขนาดใหญ่อาจทำให้เกิดปัญหาทรัพยากรหน่วยความจำส่งผลให้การปฏิเสธบริการ
- ไม่สามารถเขียนรหัสที่เชื่อถือได้ซึ่งสามารถเดินทรีไฟล์และตอบกลับอย่างเหมาะสมหากมีการเชื่อมโยงสัญลักษณ์แบบวงกลม
โอ้ดีที่ออกกฎ java.io.File หากไม่สามารถเขียน / ต่อท้ายไฟล์ได้คุณอาจไม่สามารถรู้สาเหตุได้
เราสามารถดูบทแนะนำได้ที่: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common
หากคุณมีทุกบรรทัดที่คุณจะเขียน (ต่อท้าย) ลงในไฟล์ข้อความล่วงหน้าวิธีที่แนะนำคือ 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 ...-
ตัวอย่างแบบง่าย (Java 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("----------");
[...]
}
วิธีการเหล่านี้ต้องการความพยายามเพียงเล็กน้อยในส่วนของผู้เขียนและควรเป็นที่ต้องการของผู้อื่นเมื่อเขียนไฟล์ [text]
FileNotFoundException
ที่ถูกโยนทิ้งเมื่อการดำเนินการล้มเหลว
หากคุณต้องการที่จะมีประสบการณ์ที่ค่อนข้างปราศจากความเจ็บปวดคุณยังสามารถมีลักษณะที่เป็นแพคเกจ Apache Commons IOมากขึ้นโดยเฉพาะในชั้นเรียนFileUtils
อย่าลืมตรวจสอบห้องสมุดบุคคลที่สาม Joda-Timeสำหรับการจัดการวันที่Apache Commons LangStringUtils
สำหรับการดำเนินการกับสตริงทั่วไปและสามารถทำให้โค้ดของคุณอ่านง่ายขึ้น
Java เป็นภาษาที่ยอดเยี่ยม แต่บางครั้งไลบรารี่มาตรฐานจะค่อนข้างต่ำ ทรงพลัง แต่ระดับต่ำอย่างไรก็ตาม
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
เส้น
หากคุณมีเหตุผลบางอย่างที่ต้องการแยกการกระทำของการสร้างและการเขียนเทียบเท่า Java 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()
ลำดับเหล่านี้เสียเวลาและพื้นที่อย่างแท้จริง
นี่คือวิธีที่เป็นไปได้ในการสร้างและเขียนไฟล์ใน Java:
ใช้ 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);
}
วิธีที่ดีที่สุดคือการใช้ Java7: Java 7 แนะนำวิธีใหม่ในการทำงานกับระบบไฟล์พร้อมกับคลาสยูทิลิตี้ใหม่ - ไฟล์ เมื่อใช้คลาส Files เราสามารถสร้างย้ายคัดลอกลบไฟล์และไดเรกทอรีได้เช่นกัน มันยังสามารถใช้ในการอ่านและเขียนไฟล์
public void saveDataInFile(String data) throws IOException {
Path path = Paths.get(fileName);
byte[] strToBytes = data.getBytes();
Files.write(path, strToBytes);
}
เขียนด้วย FileChannel หากคุณจัดการกับไฟล์ขนาดใหญ่ FileChannel สามารถเร็วกว่า IO มาตรฐาน รหัสต่อไปนี้เขียน String ไปยังไฟล์โดยใช้ 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 เพื่อเขียนข้อมูลไบนารีลงในไฟล์ รหัสต่อไปนี้แปลง String 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();
}
เขียนด้วย BufferedWriter: ใช้ BufferedWriter เพื่อเขียน String ไปยังไฟล์ใหม่:
public void saveDataInFile(String data) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
writer.write(data);
writer.close();
}
ผนวก String เข้ากับไฟล์ที่มีอยู่:
public void saveDataInFile(String data) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
writer.append(' ');
writer.append(data);
writer.close();
}
ฉันคิดว่านี่เป็นวิธีที่สั้นที่สุด:
FileWriter fr = new FileWriter("your_file_name.txt"); // After '.' write
// your file extention (".txt" in this case)
fr.write("Things you want to write into the file"); // Warning: this will REPLACE your old file content!
fr.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
นอกเหนือจากที่มันยังไม่ชัดเจนสิ่งที่เป็น หากเป็น a การjava.lang.String
เรียกgetBytes()
จะสร้างไบต์โดยใช้การเข้ารหัสเริ่มต้นของแพลตฟอร์มซึ่งไม่ดีมากในกรณีทั่วไป
วิธีที่ง่ายที่สุดที่ฉันสามารถหาได้:
Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
writer.write("Hello, world!");
}
อาจใช้งานได้กับ 1.7+ เท่านั้น
มันน่าลองสำหรับ Java 7+:
Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());
ดูเหมือนว่ามีแนวโน้ม ...
หากเราใช้ Java 7 ขึ้นไปและรู้เนื้อหาที่จะเพิ่ม (ต่อท้าย) ไปยังไฟล์เราสามารถใช้ประโยชน์จากวิธีการใหม่ของBufferedWriterในแพ็คเกจ NIO
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
คำสั่งที่ทรัพยากรจะปิดโดยอัตโนมัติหลังจากลองแม้ว่า OP ไม่ได้ถาม แต่ในกรณีที่เราต้องการค้นหาบรรทัดที่มีคำหลักที่เฉพาะเจาะจงเช่นconfidential
เราสามารถใช้ประโยชน์จาก API สตรีมใน Java:
//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);
ใน Java 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");
การใช้ห้องสมุด Guava ของ 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);
วิธีการเหล่านี้จะดูแลงานส่วนใหญ่ของคุณเช่นการเปิดและปิดการสตรีม แต่ไม่ได้มีไว้สำหรับจัดการไฟล์ขนาดใหญ่
การเขียนไฟล์ขนาดใหญ่โดยใช้ Buffered Stream I / O (1.7)
java.nio.file
แพคเกจสนับสนุนช่อง I / O ที่ข้อมูลการเคลื่อนไหวในบัฟเฟอร์ผ่านบางส่วนของชั้นที่สามารถสตรีมคอขวดของ I / O
String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
writer.write(s, 0, s.length());
}
วิธีนี้เป็นสิ่งที่พิเศษเนื่องจากประสิทธิภาพที่มีประสิทธิภาพโดยเฉพาะอย่างยิ่งเมื่อดำเนินการเขียนเป็นจำนวนมาก การดำเนินการบัฟเฟอร์มีผลกระทบนี้เนื่องจากไม่จำเป็นต้องเรียกใช้วิธีการเขียนของระบบปฏิบัติการสำหรับทุกไบต์เดียวลดการดำเนินการ I / O ราคาแพง
ใช้ NIO API เพื่อคัดลอก (และสร้างใหม่) ไฟล์ที่มี Outputstream (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[])
วิธีการเมื่อทำได้