1.ไอโอคืออะไร
การดำเนินการ I/O ใน Java ส่วนใหญ่อ้างถึงการใช้ Java สำหรับการดำเนินการอินพุตและเอาต์พุต กลไก Java I/O ทั้งหมดจะขึ้นอยู่กับสตรีมข้อมูลสำหรับอินพุตและเอาต์พุต สตรีม I/O ของ Java จัดเตรียมวิธีการมาตรฐานสำหรับการอ่านและเขียนข้อมูล ออบเจ็กต์ใดๆ ใน Java ที่แสดงถึงแหล่งข้อมูลจะมีวิธีการอ่านและเขียนข้อมูลในสตรีมข้อมูล
Java.io เป็นแพ็คเกจหลักสำหรับคลาสอินพุต/เอาท์พุตที่เน้นการไหลของข้อมูลส่วนใหญ่ นอกจากนี้ Java ยังให้การสนับสนุนการส่งบล็อก และใช้บล็อก IO ในไลบรารีหลัก java.nio
ข้อดีของ stream IO คือใช้งานง่าย แต่ข้อเสียคือมีประสิทธิภาพน้อยกว่า Block IO มีประสิทธิภาพมาก แต่การเขียนโปรแกรมมีความซับซ้อนมากกว่า
โมเดลจาวา IO:
การออกแบบโมเดล IO ของ Java นั้นยอดเยี่ยมมาก โดยจะใช้รูปแบบมัณฑนากรเพื่อแบ่ง Streams ตามฟังก์ชัน คุณสามารถประกอบ Streams เหล่านี้แบบไดนามิกเพื่อรับฟังก์ชันที่คุณต้องการได้ ตัวอย่างเช่น หากคุณต้องการสตรีมอินพุตไฟล์แบบบัฟเฟอร์ คุณควรใช้ FileInputStream และ BufferedInputStream ร่วมกัน
2. แนวคิดพื้นฐานของการไหลของข้อมูล
การไหลของข้อมูลคือการรวบรวมข้อมูลที่ต่อเนื่อง เช่นเดียวกับการไหลของน้ำในท่อน้ำ น้ำจะถูกจ่ายทีละนิดที่ปลายด้านหนึ่งของท่อน้ำ และสิ่งที่เห็นที่ปลายอีกด้านของท่อน้ำก็คือการไหลอย่างต่อเนื่อง ของน้ำ โปรแกรมเขียนข้อมูลสามารถเขียนข้อมูลลงในส่วนไปป์ไลน์การไหลของข้อมูลตามส่วนข้อมูลเหล่านี้จะสร้างกระแสข้อมูลแบบยาวตามลำดับ สำหรับโปรแกรมอ่านข้อมูล การแบ่งส่วนของสตรีมข้อมูลระหว่างการเขียนไม่สามารถมองเห็นได้ ในแต่ละครั้งสามารถอ่านข้อมูลได้ แต่ข้อมูลก่อนหน้าเท่านั้นที่สามารถอ่านได้ก่อน จากนั้นจึงสามารถอ่านข้อมูลในภายหลังได้ ไม่ว่าข้อมูลจะถูกเขียนเป็นชุดๆ หรือเขียนทั้งหมดพร้อมกันก็ตาม ผลเมื่ออ่านก็เหมือนกันทุกประการ
"สตรีมคือแหล่งที่มาหรือปลายทางของข้อมูลที่จัดเก็บไว้ในดิสก์หรืออุปกรณ์ต่อพ่วงอื่นๆ"
มีสามวิธีในการจัดเก็บข้อมูลบนคอมพิวเตอร์ วิธีหนึ่งคือที่จัดเก็บข้อมูลภายนอก วิธีหนึ่งคือหน่วยความจำ และอีกวิธีหนึ่งคือแคช ตัวอย่างเช่น ฮาร์ดดิสก์ ดิสก์แม่เหล็ก แฟลชไดรฟ์ USB ฯลฯ บนคอมพิวเตอร์ล้วนเป็นที่จัดเก็บข้อมูลภายนอก มีหน่วยความจำอยู่ในคอมพิวเตอร์ และแคชอยู่ใน CPU ที่จัดเก็บข้อมูลภายนอกมีความจุที่ใหญ่ที่สุด รองลงมาคือหน่วยความจำ และสุดท้ายคือแคช อย่างไรก็ตาม การอ่านข้อมูลจากที่จัดเก็บข้อมูลภายนอกจะช้าที่สุด รองลงมาคือหน่วยความจำ และแคชจะเร็วที่สุด นี่คือบทสรุปของการอ่านข้อมูลจากหน่วยความจำภายนอกไปยังหน่วยความจำและการเขียนข้อมูลจากหน่วยความจำไปยังหน่วยความจำภายนอก สำหรับความเข้าใจเกี่ยวกับหน่วยความจำและที่จัดเก็บข้อมูลภายนอก เราสามารถเข้าใจได้ง่าย ๆ ว่ามันคือคอนเทนเนอร์ กล่าวคือ ที่จัดเก็บข้อมูลภายนอกก็คือคอนเทนเนอร์ และหน่วยความจำก็คือคอนเทนเนอร์อื่น แล้วจะอ่านข้อมูลในคอนเทนเนอร์หน่วยความจำภายนอกลงในคอนเทนเนอร์หน่วยความจำได้อย่างไรและจะบันทึกข้อมูลในคอนเทนเนอร์หน่วยความจำไปยังที่จัดเก็บข้อมูลภายนอกได้อย่างไร?
ในไลบรารีคลาส Java ส่วน IO มีขนาดใหญ่มากเนื่องจากครอบคลุมฟิลด์ที่หลากหลาย:
อินพุตและเอาต์พุตมาตรฐาน การทำงานของไฟล์ สตรีมข้อมูลบนเครือข่าย สตรีมสตริง สตรีมอ็อบเจ็กต์ สตรีมไฟล์ zip ฯลฯ ใน Java สิ่งที่เป็นนามธรรมของอินพุตและเอาต์พุตเรียกว่าสตรีม ซึ่งเหมือนกับท่อน้ำที่เชื่อมต่อสองคอนเทนเนอร์ การอ่านข้อมูลจากหน่วยความจำภายนอกลงในหน่วยความจำเรียกว่าอินพุตสตรีม และการเขียนข้อมูลจากหน่วยความจำลงในหน่วยความจำภายนอกเรียกว่าสตรีมเอาต์พุต
สตรีมเป็นแนวคิดที่ชัดเจนมาก เมื่อโปรแกรมต้องการอ่านข้อมูล โปรแกรมจะเปิดสตรีมไปยังแหล่งข้อมูลนี้ อาจเป็นไฟล์ หน่วยความจำ หรือการเชื่อมต่อเครือข่าย ในทำนองเดียวกันเมื่อโปรแกรมต้องการเขียนข้อมูลก็จะเปิดสตรีมไปยังปลายทาง
แนวคิดพื้นฐานโดยสรุปมีดังนี้:
ลำดับไบต์ที่มีจุดเริ่มต้นและจุดสิ้นสุด รวมถึงสตรีมอินพุตและสตรีมเอาท์พุต
2) สตรีมอินพุต:โปรแกรมอ่านแหล่งข้อมูลจากสตรีมอินพุต แหล่งข้อมูล ได้แก่ โลกภายนอก (คีย์บอร์ด ไฟล์ เครือข่าย...) ซึ่งเป็นช่องทางการสื่อสารที่อ่านแหล่งข้อมูลเข้าสู่โปรแกรม
วัตถุประสงค์ของการใช้สตรีมข้อมูลคือเพื่อให้เอาต์พุตและอินพุตเป็นอิสระจากอุปกรณ์
อินพุตสตรีมไม่สนใจว่าแหล่งข้อมูลนั้นมาจากอุปกรณ์ใด (คีย์บอร์ด ไฟล์ เครือข่าย)
สตรีมเอาท์พุตไม่สนใจว่าข้อมูลถูกกำหนดไว้สำหรับอุปกรณ์ใด (คีย์บอร์ด ไฟล์ เครือข่าย)
3.มาตรฐาน I/O
โปรแกรม Java สามารถแลกเปลี่ยนข้อมูลโดยย่อกับโลกภายนอกผ่านพารามิเตอร์บรรทัดคำสั่ง ในเวลาเดียวกัน ยังกำหนดวิธีการแลกเปลี่ยนข้อมูลกับอุปกรณ์อินพุตและเอาต์พุตมาตรฐาน เช่น คีย์บอร์ดและจอภาพ ผ่านไฟล์ข้อมูลในรูปแบบข้อมูลใด ๆ สามารถแลกเปลี่ยนกับโลกภายนอกได้
1. พารามิเตอร์บรรทัดคำสั่งผลการวิ่ง:
args[0] คือ <Java>
args[1] คือ <C>
อาร์กิวเมนต์ [2] คือ <VB>
สตรีมข้อมูลมาตรฐานที่มาพร้อมกับระบบ Java: java.lang.System:
สังเกต:
(1) คลาส System ไม่สามารถสร้างอ็อบเจ็กต์ได้และสามารถใช้ได้เพียงสมาชิกคงที่สามตัวเท่านั้นโดยตรง
(2) เมื่อใดก็ตามที่ดำเนินการตามวิธีการหลัก ออบเจ็กต์สามรายการข้างต้นจะถูกสร้างขึ้นโดยอัตโนมัติ
1) สตรีมเอาต์พุตมาตรฐาน System.out
System.out ส่งออกข้อมูลไปยังอุปกรณ์เอาต์พุตมาตรฐาน และประเภทข้อมูลคือ PrintStream วิธี:
2) สตรีมอินพุตมาตรฐาน System.in
System.in อ่านข้อมูลอุปกรณ์อินพุตมาตรฐาน (รับข้อมูลจากอินพุตมาตรฐาน ซึ่งโดยทั่วไปคือคีย์บอร์ด) และประเภทข้อมูลคือ InputStream วิธี:
3) สตรีมข้อผิดพลาดมาตรฐาน
System.err แสดงผล error มาตรฐาน และประเภทข้อมูลคือ PrintStream โปรดดู API สำหรับคำแนะนำโดยละเอียด
เอาต์พุตมาตรฐานเรียกเมธอด println ผ่าน System.out เพื่อเรียกพารามิเตอร์เอาต์พุตและตัดบรรทัดใหม่ ในขณะที่เมธอด print ส่งออกพารามิเตอร์ แต่ไม่ตัดบรรทัดใหม่ วิธีการ println หรือ print ใช้วิธีการต่างๆ มากมายในการส่งออกข้อมูลประเภทพื้นฐานผ่านการโอเวอร์โหลด รวมถึงประเภทพารามิเตอร์เอาท์พุต เช่น บูลีน ถ่าน int ยาว ลอย และสองเท่า ในเวลาเดียวกัน วิธีการที่มีประเภทพารามิเตอร์เอาท์พุตเป็น char[], String และ Object ก็มีการโอเวอร์โหลดเช่นกัน ในหมู่พวกเขา เมธอด print(Object) และ println(Object) จะเรียกเมธอด toString ของพารามิเตอร์ Object ณ รันไทม์
StandardInputOutput ระดับสาธารณะ {
โมฆะคงสาธารณะ main (String args []) {
สตริง;
//สร้างตัวอ่านบัฟเฟอร์เพื่ออ่านข้อมูลทีละบรรทัดจากคีย์บอร์ด
InputStreamReader ir = InputStreamReader ใหม่ (System.in);
BufferedReader ใน = BufferedReader ใหม่ (ir);
System.out.println("ระบบ Unix: ctrl-d หรือ ctrl-c เพื่อออก"
+ "/nระบบ Windows: Ctrl-z ออก");
พยายาม {
//อ่านข้อมูลหนึ่งบรรทัดแล้วส่งออกไปยังมอนิเตอร์ตามมาตรฐาน
s = in.readLine();
// หากข้อผิดพลาด I/O เกิดขึ้นเมื่อเมธอด readLine() กำลังทำงานอยู่ IOException จะถูกส่งออกไป
ในขณะที่ (s != null) {
System.out.println("อ่าน: " + s);
s = in.readLine();
-
// ปิดเครื่องอ่านบัฟเฟอร์
ใน.ปิด();
} catch (IOException e) { // จับข้อยกเว้น IO ใด ๆ
e.printStackTrace();
-
-
-
4.java.IO สถาปัตยกรรมแบบลำดับชั้น
สิ่งที่สำคัญที่สุดในแพ็คเกจ Java.io ทั้งหมดคือ 5 คลาสและอินเทอร์เฟซ คลาสทั้งห้าหมายถึง File, OutputStream, InputStream, Writer และ Reader โดยอินเทอร์เฟซหนึ่งหมายถึง Serializable เมื่อคุณเชี่ยวชาญการดำเนินการ IO หลักเหล่านี้แล้ว คุณจะมีความเข้าใจเบื้องต้นเกี่ยวกับระบบ IO ใน Java
Java I/O ส่วนใหญ่ประกอบด้วยระดับต่อไปนี้ รวมถึงสามส่วน:
1. ส่วนหลักของส่วนสตรีมมิ่ง IO;
2. ส่วนที่ไม่ใช่การสตรีม ส่วนใหญ่จะรวมบางคลาสที่สนับสนุนส่วนการสตรีม เช่น: คลาสไฟล์, คลาส RandomAccessFile และคลาส FileDescriptor;
3. คลาสอื่นๆ - คลาสที่เกี่ยวข้องกับความปลอดภัยในส่วนการอ่านไฟล์ เช่น คลาส SerializablePermission และคลาสระบบไฟล์ที่เกี่ยวข้องกับระบบปฏิบัติการภายในเครื่อง เช่น คลาส FileSystem, คลาส Win32FileSystem และคลาส WinNTFileSystem
ชั้นเรียนหลักมีดังนี้:
1. ไฟล์ (ลักษณะไฟล์และการจัดการ): ใช้สำหรับข้อมูลคำอธิบายของไฟล์หรือไดเร็กทอรี เช่น การสร้างไดเร็กทอรีใหม่ การแก้ไขชื่อไฟล์ การลบไฟล์ การกำหนดเส้นทางของไฟล์ เป็นต้น
2. InputStream (การดำเนินการรูปแบบไบนารี): คลาสนามธรรม การดำเนินการอินพุตแบบไบต์ และเป็นคลาสหลักของสตรีมอินพุตทั้งหมด กำหนดลักษณะทั่วไปที่สตรีมอินพุตทั้งหมดมี
3. OutputStream (การดำเนินการรูปแบบไบนารี): คลาสนามธรรม การดำเนินการเอาต์พุตแบบไบต์ เป็นคลาสพาเรนต์ของเอาต์พุตสตรีมทั้งหมด กำหนดลักษณะทั่วไปที่สตรีมเอาต์พุตทั้งหมดมี
อักขระใน Java ใช้มาตรฐาน Unicode อักขระหนึ่งตัวคือ 16 บิต นั่นคืออักขระหนึ่งตัวแสดงด้วยไบต์สองไบต์ ด้วยเหตุนี้จึงมีการแนะนำสตรีมสำหรับการประมวลผลอักขระใน JAVA
4. เครื่องอ่าน (การดำเนินการกับรูปแบบไฟล์): คลาสนามธรรม, การดำเนินการอินพุตตามอักขระ
5. Writer (การดำเนินการกับรูปแบบไฟล์): คลาสนามธรรม, การดำเนินการเอาต์พุตตามอักขระ
6. RandomAccessFile (การทำงานของไฟล์แบบสุ่ม): มีฟังก์ชันที่หลากหลายและ สามารถดำเนินการเข้าถึง (อินพุตและเอาต์พุต) ได้จากตำแหน่งใดก็ได้ในไฟล์
สถาปัตยกรรมของสตรีม IO ใน Java เป็นดังนี้:
5. คลาสไฟล์ที่ไม่ใช่สตรีมมิ่ง - คลาสไฟล์
-
คำอธิบาย: วิธีการของคลาสไฟล์:
(1) มีอยู่ () ทดสอบว่ามีไฟล์หรือไดเร็กทอรีที่ระบุอยู่ในดิสก์หรือไม่
(2) mkdir() สร้างไดเร็กทอรีที่ระบุโดยวัตถุไฟล์ (ไดเร็กทอรีชั้นเดียว)
(3) createNewFile() สร้างไฟล์ที่ระบุโดยวัตถุไฟล์
(4) list() ส่งคืนสตริงชื่อไฟล์ทั้งหมดในไดเร็กทอรี
6. ไลบรารีคลาสสตรีม Java.IO
แพ็คเกจ java.io มีคลาสทั้งหมดที่จำเป็นสำหรับการสตรีม I/O มีคลาสพื้นฐานสี่คลาสในแพ็คเกจ java.io: คลาส InputStream, OutputStream, Reader และ Writer ซึ่งจัดการสตรีมไบต์และสตรีมอักขระตามลำดับ:
I/O สตรีมข้อมูลพื้นฐาน
อินพุต/เอาต์พุต
สตรีมไบต์
สตรีมตัวละคร
สตรีมอินพุต
กระแสเข้า
ผู้อ่าน
สตรีมเอาท์พุต
เอาท์พุตสตรีม
นักเขียน
กระแสข้อมูลรูปแบบอื่น ๆ ใน Java นั้นได้มาจากสิ่งเหล่านี้:
เวอร์ชัน JDK1.4 เริ่มแนะนำไลบรารีคลาส I/O ใหม่ ซึ่งอยู่ในแพ็คเกจ java.nio ไลบรารีคลาส I/O ใหม่ใช้แชนเนลและบัฟเฟอร์เพื่อปรับปรุงประสิทธิภาพของการดำเนินการ I/O
ในแพ็คเกจ java.io นั้น java.io.InputStream แสดงถึงสตรีมอินพุตแบบไบต์ และ java.io.OutputStream แสดงถึงสตรีมเอาต์พุตแบบไบต์ ซึ่งอยู่ที่ระดับบนสุดของแพ็คเกจ java.io ทั้งสองคลาสเป็นคลาสนามธรรม ซึ่งหมายความว่าไม่สามารถสร้างอินสแตนซ์ได้ และจะต้องถูกคลาสย่อยเพื่อให้บรรลุฟังก์ชันบางอย่าง
1. การจำแนกประเภทเฉพาะของโฟลว์ io1. การจำแนกโดยรวมตามประเภท I/O:
1. หน่วยความจำ 1) อ่านและเขียนข้อมูลจาก/ไปยังอาร์เรย์หน่วยความจำ: CharArrayReader, CharArrayWriter, ByteArrayInputStream, ByteArrayOutputStream
2) อ่านและเขียนข้อมูลจาก/ไปยังสตริงหน่วยความจำ StringReader, StringWriter, StringBufferInputStream
2. ไปป์ไลน์ ใช้อินพุตและเอาต์พุตไปป์ไลน์ (การสื่อสารระหว่างกระบวนการ): PipedReader, PipedWriter, PipedInputStream, PipedOutputStream
3.ไฟล์สตรีมไฟล์ อ่านและเขียนไฟล์: FileReader, FileWriter, FileInputStream, FileOutputStream
4. อินพุตและเอาต์พุตของวัตถุ ObjectSerialization : ObjectInputStream, ObjectOutputStream
5. สตรีมข้อมูล DataConversion อ่านและเขียนตามประเภทข้อมูลพื้นฐาน (ข้อมูลที่ประมวลผลเป็นประเภทพื้นฐานของ Java (เช่น บูลีน ไบต์ จำนวนเต็ม และตัวเลขทศนิยม)): DataInputStream, DataOutputStream
6.การพิมพ์ มีวิธีการพิมพ์ที่สะดวกสบาย: PrintWriter, PrintStream
7. การบัฟเฟอร์แคชข้อมูลเมื่ออ่านหรือเขียนเพื่อลดจำนวน I/O: BufferedReader, BufferedWriter, BufferedInputStream, BufferedOutputStream
8. กรองกรองกระแส กรองเมื่อข้อมูลถูกอ่านหรือเขียน: FilterReader, FilterWriter, FilterInputStream, FilterOutputStream pass
9. การต่อข้อมูลจะรวมอินพุตและ เชื่อมต่อสตรีมอินพุตหลายรายการเป็นสตรีมอินพุตเดียว: SequenceInputStream
10.การนับนับ แถวเมื่ออ่านข้อมูล: LineNumberReader, LineNumberInputStream
11.Peeking Ahead ดำเนินการอ่านล่วงหน้าผ่านกลไกการแคช: PushbackReader, PushbackInputStream
12. การแปลงระหว่างไบต์และอักขระ จะแปลงสตรีมไบต์เป็นสตรีมอักขระตามมาตรฐานการเข้ารหัส/ถอดรหัสบางอย่าง หรือดำเนินการแปลงย้อนกลับ (คลาสการแปลงสตรีมเป็น Reader, Writer): InputStreamReader, OutputStreamWriter
2. จำแนกตามแหล่งข้อมูล (ปลายทาง):
1. ไฟล์: FileInputStream, FileOutputStream, FileReader, FileWriter
2. ไบต์ []: ByteArrayInputStream, ByteArrayOutputStream
3. ถ่าน[]: CharArrayReader, CharArrayWriter
4. สตริง: StringBufferInputStream, StringReader, StringWriter
5. สตรีมข้อมูลเครือข่าย: InputStream, OutputStream, Reader, Writer
7. ไบต์สตรีม InputStream/OutputStream
InputStream เป็นคลาสอินพุตแบบไบต์ โดยตัวมันเองเป็นคลาสนามธรรมและต้องอาศัยคลาสย่อยเพื่อใช้ฟังก์ชันต่างๆ สตรีมที่สืบทอดมาจากข้อมูลอินพุต InputStream เข้าสู่โปรแกรมและหน่วยข้อมูลเป็นไบต์ (8 บิต)
InputStream เป็นคลาสที่ใช้ในการป้อนข้อมูลไบต์ ดังนั้นคลาส InputStream จึงมีวิธีการอ่านที่โอเวอร์โหลดสามวิธีในคลาส Inputstream:
(1) public abstract int read(): อ่านไบต์ของข้อมูล และค่าที่ส่งคืนจะเป็นค่าประเภท int โดยมีบิตสูงเต็มไปด้วย 0 หากค่าที่ส่งคืน = -1 หมายความว่าไม่มีการอ่านไบต์และงานการอ่านสิ้นสุดลงแล้ว
(2) public int read(byte b[ ]): อ่านข้อมูลไบต์ b.length และใส่ลงในอาร์เรย์ b ค่าที่ส่งคืนคือจำนวนไบต์ที่อ่าน วิธีการนี้ใช้งานได้จริงโดยการเรียกวิธีการถัดไป (3) public int read(byte b[ ], int off, int len): อ่านข้อมูลได้มากถึง len ไบต์ของข้อมูลจากสตรีมอินพุต และเก็บไว้ที่ออฟเซ็ตของ off ใน อาร์เรย์ข
(4) public int available(): ส่งกลับจำนวนไบต์ที่สามารถอ่านได้ในสตรีมอินพุต หมายเหตุ: หากอินพุตถูกบล็อก เธรดปัจจุบันจะถูกระงับ หากวัตถุ InputStream เรียกใช้เมธอดนี้ ก็จะคืนค่า 0 เท่านั้น เมธอดนี้จะต้องถูกเรียกโดยวัตถุคลาสย่อยที่สืบทอดคลาส InputStream จึงจะมีประโยชน์
(5) การข้ามแบบยาวสาธารณะ (long n): ละเว้น n ไบต์ในสตรีมอินพุต ค่าที่ส่งคืนคือจำนวนไบต์ที่ถูกละเลยจริง ๆ ข้ามบางไบต์เพื่ออ่าน (6) public int close(): เราคือหลังการใช้งาน สตรีมที่เราเปิดต้องถูกปิด
หมวดหมู่ย่อยหลัก:
1) FileInputStream ใช้ไฟล์เป็น InputStream เพื่อให้ทราบการดำเนินการอ่านของไฟล์ 2) ByteArrayInputStream: ใช้บัฟเฟอร์ในหน่วยความจำเป็น InputStream 3) StringBufferInputStream: ใช้วัตถุ String เป็น InputStream
4) PipedInputStream: นำแนวคิดของไปป์ไปใช้ ซึ่งส่วนใหญ่ใช้ในเธรด 5) SequenceInputStream: ผสานหลาย InputStreams ให้เป็น InputStream เดียว
หมวดหมู่ย่อยหลัก:
1) ByteArrayOutputStream: เก็บข้อมูลไว้ในบัฟเฟอร์ในหน่วยความจำ
2) FileOutputStream: เก็บข้อมูลไว้ในไฟล์
3) PipedOutputStream: นำแนวคิดของไปป์ไปใช้ ซึ่งส่วนใหญ่ใช้ในเธรด
4) SequenceOutputStream: รวม OutStream หลายรายการไว้ใน OutStream เดียว
การกำหนดจุดสิ้นสุดของสตรีม: เมื่อค่าส่งคืนของเมธอด read() คือ -1; เมื่อค่าส่งคืนของ readLine() เป็นโมฆะ
3. สตรีมอินพุตไฟล์: คลาส FileInputStreamFileInputStream สามารถใช้เมธอด read() เพื่ออ่านทีละไบต์และส่งกลับเป็นประเภท int หรือใช้เมธอด read() เพื่ออ่านในอาร์เรย์ไบต์ จำนวนไบต์ที่อ่านตามจำนวนองค์ประกอบใน อาร์เรย์ไบต์ ในกระบวนการอ่านหรือเขียนไฟล์ทั้งหมด ไบต์อาร์เรย์มักจะถูกใช้เป็นบัฟเฟอร์ เนื่องจากไบต์อาร์เรย์มักจะมีบทบาทระดับกลางในการรับข้อมูล
วิธีใช้(2)
FileInputStream ใน=newFileInputStream(“d: /abc.txt”);
ตัวอย่างโปรแกรม:
แสดงเนื้อหาของโปรแกรม InputFromFile.java บนมอนิเตอร์
TestFile คลาสสาธารณะ {
โมฆะคงที่สาธารณะ main (String args []) พ่น IOException {
พยายาม{
FileInputStream rf=new FileInputStream("InputFromFile.java");
int n=512; ไบต์บัฟเฟอร์[]=ไบต์ใหม่[n];
ในขณะที่((rf.read(บัฟเฟอร์,0,n)!=-1)&&(n>0)){
System.out.println (สตริงใหม่ (บัฟเฟอร์) );
-
System.out.println();
rf.ปิด();
} จับ (IOException IOe){
System.out.println(IOe.toString());
-
-
-
คลาส FileOutputStream ใช้ในการประมวลผลสตรีมข้อมูลที่ใช้ไฟล์เป็นปลายทางเอาต์พุตข้อมูล สตริงที่แสดงชื่อไฟล์ ซึ่งอาจเป็นอ็อบเจ็กต์ File หรือ FileDescriptor ก็ได้
มีสองวิธีในการสร้างออบเจ็กต์สตรีมไฟล์:
วิธีที่ 1:
ไฟล์ f=ไฟล์ใหม่ ("d:/myjava/write.txt ");
FileOutputStream out= ใหม่ FileOutputStream (f);
วิธีที่ 2:
FileOutputStream out=new FileOutputStream("d:/myjava/write.txt ");
วิธีที่ 3: ตัวสร้างใช้วัตถุ FileDescriptor() เป็นพารามิเตอร์
FileDescriptor() fd=ใหม่ FileDescriptor();
FileOutputStream f2=FileOutputStream ใหม่(fd);
วิธีที่ 4: ตัวสร้างใช้ชื่อไฟล์เป็นพารามิเตอร์ตัวแรกและค่าบูลีนเป็นพารามิเตอร์ตัวที่สอง
FileOutputStream f=new FileOutputStream("d:/abc.txt",true);
หมายเหตุ: (1) เมื่อเขียนข้อมูลลงไฟล์ หากไฟล์มีอยู่แล้ว ไฟล์ที่มีอยู่จะถูกเขียนทับ (2) เมื่อการดำเนินการอ่าน/เขียนสิ้นสุดลง ควรเรียกใช้เมธอด close เพื่อปิดสตรีม
-
TestFile คลาสสาธารณะ {
โมฆะคงที่สาธารณะ main (String args []) พ่น IOException {
พยายาม {
ไฟล์ inFile = ไฟล์ใหม่ ("copy.java");
ไฟล์ outFile = ไฟล์ใหม่ ("copy2.java");
FileInputStream finS = FileInputStream ใหม่ (inFile);
FileOutputStream foutS = FileOutputStream ใหม่ (outFile);
อินท์ค;
ในขณะที่ ((c = finS.read()) != -1) {
foutS.write(c);
-
finS.ปิด();
foutS.ปิด();
} จับ (IOException จ) {
System.err.println("FileStreamsTest: " + e);
-
-
-
การเข้าถึงคอมพิวเตอร์ไปยังอุปกรณ์ภายนอกนั้นใช้เวลานาน ยิ่งความถี่ในการเข้าถึงหน่วยความจำภายนอกสูงเท่าไร ความน่าจะเป็นที่ CPU จะไม่มีการใช้งานก็จะยิ่งมากขึ้นเท่านั้น เพื่อลดจำนวนการเข้าถึงหน่วยความจำภายนอก ควรอ่านและเขียนข้อมูลมากขึ้นในการเข้าถึงอุปกรณ์ต่อพ่วงเพียงครั้งเดียว ด้วยเหตุนี้ นอกเหนือจากกลไกการอ่านและการเขียนที่จำเป็นสำหรับการแลกเปลี่ยนข้อมูลระหว่างโปรแกรมและโหนดโฟลว์แล้ว ควรเพิ่มกลไกการบัฟเฟอร์ด้วย สตรีมบัฟเฟอร์หมายความว่าแต่ละสตรีมข้อมูลได้รับการจัดสรรบัฟเฟอร์ และบัฟเฟอร์คือหน่วยความจำที่จัดเก็บข้อมูลชั่วคราว ซึ่งสามารถลดจำนวนการเข้าถึงฮาร์ดดิสก์และปรับปรุงประสิทธิภาพการรับส่งข้อมูลได้
BufferedInputStream: เมื่อเขียนข้อมูลไปยังสตรีมบัฟเฟอร์ ข้อมูลจะถูกเขียนลงในบัฟเฟอร์ก่อน หลังจากที่บัฟเฟอร์เต็ม ระบบจะส่งข้อมูลไปยังอุปกรณ์เอาท์พุตทันที
BufferedOutputStream: เมื่ออ่านข้อมูลจากสตรีมที่บัฟเฟอร์ ระบบจะอ่านข้อมูลจากบัฟเฟอร์ก่อน เมื่อบัฟเฟอร์ว่างเปล่า ระบบจะอ่านข้อมูลจากอุปกรณ์อินพุตไปยังบัฟเฟอร์
เชื่อมต่อ BufferedInputStream กับ FileInputStream
FileInputStreamin=newFileInputStream( "file1.txt " );
BufferedInputStreambin=newBufferedInputStream(ใน);
2) เขียนหน่วยความจำลงไฟล์:
เชื่อมต่อ BufferedOutputStream กับ FileOutputStream
FileOutputStreamout=newFileOutputStream(“file1.txt”);
BufferedOutputStreambin=newBufferedInputStream(ออก);
ReadWriteToFile คลาสสาธารณะ {
โมฆะคงที่สาธารณะ main (String args []) พ่น IOException {
InputStreamReader sin = InputStreamReader ใหม่ (System.in);
BufferedReader bin = BufferedReader ใหม่ (บาป);
FileWriter ออก = FileWriter ใหม่ ("myfile.txt");
การแข่งขัน BufferedWriter = BufferedWriter ใหม่ (ออก);
สตริง;
ในขณะที่ ((s = bin.readLine()).ความยาว() > 0) {
การแข่งขัน.write(s, 0, s.length());
-
-
-
8. นักเขียน/ผู้อ่านสตรีมอักขระ
อักขระใน Java ใช้มาตรฐาน Unicode อักขระหนึ่งตัวมีขนาด 16 บิต นั่นคืออักขระหนึ่งตัวแสดงด้วยไบต์สองไบต์ ด้วยเหตุนี้จึงมีการแนะนำสตรีมสำหรับการประมวลผลอักขระใน JAVA
คลาสนามธรรมสำหรับการอ่านสตรีมตัวละคร วิธีการเดียวที่คลาสย่อยต้องใช้คือ read(char[], int, int) และ close() อย่างไรก็ตาม คลาสย่อยส่วนใหญ่จะแทนที่วิธีการบางอย่างที่กำหนดไว้ที่นี่เพื่อให้มีประสิทธิภาพมากขึ้นและ/หรือฟังก์ชันเพิ่มเติม
1) FileReader: สอดคล้องกับ FileInputStream โดยส่วนใหญ่จะใช้เพื่ออ่านไฟล์อักขระ โดยใช้การเข้ารหัสอักขระเริ่มต้น และมีตัวสร้างสามตัว:
(1) ใช้ชื่อไฟล์เป็นสตริง: FileReader f=new FileReader(“c:/temp.txt”);
(2) ตัวสร้างใช้วัตถุ File เป็นพารามิเตอร์
ไฟล์ f=ไฟล์ใหม่ (“c:/temp.txt”);
FileReader f1=ตัวอ่านไฟล์ใหม่(f);
(3) ตัวสร้างใช้วัตถุ FileDescriptor เป็นพารามิเตอร์
FileDescriptor() fd=ใหม่ FileDescriptor()
FileReader f2=ตัวอ่านไฟล์ใหม่(fd);
(1) ใช้อาร์เรย์อักขระที่ระบุเป็นพารามิเตอร์: CharArrayReader(char[])
(2) ใช้อาร์เรย์อักขระเป็นสตรีมอินพุต: CharArrayReader(char[], int, int)
หากต้องการอ่านสตริง ตัวสร้างจะเป็นดังนี้: public StringReader(String s);
2) CharArrayReader: สอดคล้องกับ ByteArrayInputStream
3) StringReader: สอดคล้องกับ StringBufferInputStream
4) InputStreamReader
อ่านไบต์จากอินพุตสตรีมและแปลงเป็นอักขระ: Public inputstreamReader(inputstream is);
5) FilterReader: อนุญาตให้กรองสตรีมอักขระ
ป้องกัน filterReader (Reader r);
6) BufferReader: ยอมรับวัตถุ Reader เป็นพารามิเตอร์และเพิ่มบัฟเฟอร์อักขระลงไป ใช้เมธอด readline() เพื่ออ่านบรรทัด
Public BufferReader (Reader r);
วิธีการหลัก:
(1) publicintread()throwsIOException;//อ่านอักขระ ค่าที่ส่งคืนคืออักขระที่อ่าน
(2) publicintread(charcbuf[])throwsIOException;/*อ่านชุดอักขระลงในอาร์เรย์ cbuf[] และค่าที่ส่งคืนคือจำนวนอักขระที่อ่านจริง*/
(3) publicabstractintread (charcbuf [], intoff, intlen) พ่น IOException;
/*อ่านอักขระ len และจัดเก็บโดยเริ่มจากตัวห้อยจากอาร์เรย์ cbuf[] ค่าที่ส่งคืนคือจำนวนอักขระจริงที่อ่าน วิธีนี้จะต้องนำไปใช้โดยคลาสย่อย*/
คลาสนามธรรมสำหรับการเขียนสตรีมตัวละคร วิธีการเดียวที่คลาสย่อยต้องใช้คือ write(char[], int, int), flush() และ close() อย่างไรก็ตาม คลาสย่อยส่วนใหญ่จะแทนที่วิธีการบางอย่างที่กำหนดไว้ที่นี่เพื่อให้มีประสิทธิภาพมากขึ้นและ/หรือฟังก์ชันเพิ่มเติม หมวดหมู่ย่อยมีดังนี้:
1) FileWrite: สอดคล้องกับ FileOutputStream และเขียนข้อมูลประเภทอักขระลงในไฟล์ โดยใช้การเข้ารหัสอักขระเริ่มต้นและขนาดบัฟเฟอร์
สาธารณะ FileWrite (ไฟล์ f);
2) chararrayWrite: สอดคล้องกับ ByteArrayOutputStream โดยใช้บัฟเฟอร์อักขระเป็นเอาต์พุต
CharArrayWrite สาธารณะ ();
3) PrintWrite: สร้าง PrintWriter สาธารณะเอาต์พุตที่จัดรูปแบบแล้ว (ระบบปฏิบัติการเอาท์พุตสตรีม);
4) filterWriter: ใช้เพื่อเขียนตัวกรองสตรีมอักขระที่ได้รับการป้องกัน FilterWriter(Writer w);
5) PipedWriter: สอดคล้องกับ PipedOutputStream
6) StringWriter: ไม่มีสตรีมเชิงไบต์ที่สอดคล้องกัน
วิธีการหลัก:
(1) publicvoidwrite(intc)พ่นIOException; //เขียน 16 บิตล่างของค่าจำนวนเต็ม c ไปยังเอาต์พุตสตรีม (2) publicvoidwrite(charcbuf[])พ่นIOException; //เขียนอาร์เรย์อักขระ cbuf[] ไปยังสตรีมเอาต์พุต ( 3) publicabstractvoidwrite (charcbuf [], intoff, intlen) พ่น IOException; // เขียนอักขระ len โดยเริ่มจากดัชนีปิดในอาร์เรย์อักขระ cbuf [] ไปยังสตรีมเอาต์พุต (4) publicvoidwrite (Stringstr) พ่น IOException; // เขียนอักขระเข้า string str ถูกเขียนไปยังเอาท์พุตสตรีม (5) publicvoidwrite(Stringstr,intoff,intlen)throwsIOException; //เขียนอักขระ len โดยเริ่มจากดัชนีปิดใน string str ไปยังเอาท์พุตสตรีม (6) ล้าง() / /ล้างสตรีมเอาท์พุตและ ส่งออกไบต์บัฟเฟอร์ทั้งหมด
(7) ปิด () ปิดกระแส publicabstractvoidclose () พ่น IOException
3. ความแตกต่างระหว่าง InputStream และ Reader ความแตกต่างระหว่าง OutputStream และ Writer
โมฆะคงที่สาธารณะ main (String args []) พ่น IOException {
System.out.println("ใช้การเข้ารหัสอักขระ Unicode ในหน่วยความจำ: ");
ถ่าน c='ดี';
int lowBit=c&0xFF; int สูงBit=(c&0xFF00)>>8;
System.out.println(""+lowBit+" "+highBit);
สตริง s="ตกลง";
System.out.println("การเข้ารหัสอักขระเริ่มต้นของระบบปฏิบัติการภายในเครื่อง:");
readBuff(s.getBytes());
System.out.println("การใช้การเข้ารหัสอักขระ GBK:");
readBuff(s.getBytes("GBK"));
System.out.println("การเข้ารหัสอักขระ UTF-8:");
readBuff(s.getBytes("UTF-8")); }
-
9. คลาสย่อยของคลาสข้อยกเว้น IOException
1.EOFException ระดับสาธารณะ:
ข้อยกเว้นประเภทนี้จะเกิดขึ้นเมื่อถึงจุดสิ้นสุดของไฟล์หรือจุดสิ้นสุดของอินพุตสตรีมอย่างผิดปกติ
2. FileNotFoundException ระดับสาธารณะ:
เกิดข้อยกเว้นเมื่อไม่พบไฟล์
3.คลาสสาธารณะขัดจังหวะIOException:
ข้อยกเว้นประเภทนี้ถูกโยนทิ้งเมื่อการดำเนินการ I/O ถูกขัดจังหวะ