1: BufferedWriter
1. บทนำเกี่ยวกับฟังก์ชั่นคลาส:
BufferedWriter, Cache Character Output Stream ฟังก์ชั่นของมันคือการให้ฟังก์ชั่นแคชสำหรับสตรีมเอาต์พุตอักขระพื้นฐานที่เข้ามา ในทำนองเดียวกันเมื่อใช้สตรีมเอาท์พุทอักขระพื้นฐานเพื่อเขียนอักขระหรืออาร์เรย์อักขระไปยังปลายทางการเชื่อมต่อกับปลายทางจะต้องเปิดทุกครั้งที่เขียน การเข้าถึงที่พบบ่อยดังกล่าวมีประสิทธิภาพอย่างต่อเนื่องและอาจทำให้เกิดความเสียหายบางอย่างกับสื่อจัดเก็บข้อมูล ตัวอย่างเช่นเมื่อเราเขียนไบต์ไปยังดิสก์อย่างต่อเนื่องมันจะเกินจริงในการเขียนหน่วยที่มีขนาดใหญ่มากของ G ไปยังไฟล์ที่ระบุบนดิสก์และถ้าเราไม่เขียนไบต์ช่องทางไปยังดิสก์นี้จะต้องเปิดหนึ่งครั้ง ผลลัพธ์นี้น่ากลัวอย่างไม่ต้องสงสัย และเมื่อเราใช้ BufferedWriter เพื่อห่อกระแสเอาท์พุทอักขระพื้นฐานเช่น filereader เราสามารถเขียนอักขระที่จะเขียนลงในไฟล์ในโปรแกรมไปยังพื้นที่แคชในตัวของ BufferedWriter แล้วเมื่อถึงจำนวนหนึ่ง ในเวลานี้ Filereader สามารถเปิดช่องและเขียนบล็อกข้อมูลนี้ไปยังไฟล์ แม้ว่ามันจะเป็นไปไม่ได้ที่จะบรรลุผลของการเขียนข้อมูลทั้งหมดไปยังดิสก์ในการเข้าถึงครั้งเดียว แต่ก็ช่วยปรับปรุงประสิทธิภาพอย่างมากและลดจำนวนการเข้าถึงดิสก์! นี่คือความสำคัญของมัน หลักการทำงานเฉพาะของมันถูกกล่าวถึงสั้น ๆ ที่นี่: อาจทำให้เกิดความสับสนที่นี่ คุณสามารถดูที่ซอร์สโค้ดโดยละเอียด หากคุณไม่เข้าใจลองย้อนกลับไปที่นี่ เมื่อใดก็ตามที่คุณเขียนอักขระหรืออาร์เรย์อักขระลงใน bufferedWriter ในโปรแกรมคุณจะตรวจสอบว่าอาร์เรย์อักขระแคช BUF (ขนาดของ BUF เป็นค่าเริ่มต้นหรือระบุเมื่อสร้าง BW โดยทั่วไปจะใช้ค่าเริ่มต้น) เต็ม หากไม่เต็มตัวละครจะถูกเขียนลงใน BUF ถ้ามันเต็มนักเขียนพื้นฐาน (char [] b, int ปิด, int เรียกว่า len) เขียนตัวละครทั้งหมดใน buf ไปยังพื้นฐานในครั้งเดียวถ้าอาร์เรย์ของตัวละครถูกเขียนถ้า buf เต็มไปด้วยการประมวลผลเมื่อมันเต็มไปด้วยความยาวของตัวละคร อักขระทั้งหมดใน BUF ที่จะเขียนออกไปจากนั้นจัดเก็บอักขระที่จะเขียนใน BUF (ที่เก็บข้อมูลจากตัวห้อย 0) หากอักขระที่จะเขียนออกเกินความยาวของ BUF จากนั้นเขียนโดยตรง
2. บทนำสู่ BufferedWriter API:
ตอบ: คำหลักนักเขียนเอกชนออก; สตรีมเอาท์พุทอักขระที่ต่ำกว่าถ่านส่วนตัว CB []; อาร์เรย์บัฟเฟอร์ส่วนตัว int nchars, nextchar; NCHARS-ขนาดของขนาดของ NCHARS, NextCHAR-Subscript ของอักขระถัดไปใน CB ส่วนตัวคงที่ int เริ่มต้น Charbuffersize = 8192; CB ขนาดเริ่มต้นสตริงส่วนตัว Lineparator; อักขระใหม่ที่ใช้สำหรับวิธีการใหม่ แพลตฟอร์มที่แตกต่างกันมีค่าที่แตกต่างกัน B: สร้างวิธีการ BufferedWriter (Writer Out) สร้าง BufferedWriter BW โดยใช้ขนาด CB เริ่มต้น BufferedWriter (นักเขียน Int SZ) สร้าง BufferedWriter BW โดยใช้ขนาด CB เริ่มต้น C: วิธีการทั่วไปเป็นโมฆะปิด () ปิดสตรีมนี้และเผยแพร่ทรัพยากรที่เกี่ยวข้องกับสตรีมนี้ Void Flushbuffer () ล้างอักขระที่แคชใน CB ลงในส่วนพื้นฐาน, Void Flush () รีเฟรชสตรีมนี้และรีเฟรชกระแสหลักของสตรีมโมฆะ NEWLINE () เขียนอักขระใหม่ เป็นโมฆะเขียน (int c) เขียนอักขระตัวเดียวลงใน CB เป็นโมฆะเขียน (ถ่าน cbuf [], int ปิด, int len) เขียนความยาวอักขระของ len จากตัวห้อยออกไปเป็น cb void เขียน (สตริง s, int ปิด, int len) เขียนส่วนหนึ่งของสตริงถึง cb
3. การวิเคราะห์รหัสที่มา
แพ็คเกจ com.chy.io.original.code; นำเข้า java.io.ioException; นำเข้า java.io.printwriter;/*** ให้ฟังก์ชั่นบัฟเฟอร์สำหรับสตรีมเอาต์พุตอักขระและปรับปรุงประสิทธิภาพ คุณสามารถใช้อักขระที่ระบุเพื่อบัฟเฟอร์ขนาดอาร์เรย์หรืออักขระเริ่มต้นเพื่อบัฟเฟอร์ขนาดอาร์เรย์ */BufferedWriter ระดับสาธารณะขยายนักเขียน {// ARRAY BASE Array Private Writer Out; // บัฟเฟอร์อาร์เรย์ส่วนตัวถ่าน CB []; // nchars-จำนวนอักขระทั้งหมดใน CB, NextChar-ตัวห้อยของอักขระถัดไปใน CB ส่วนตัว int nchars, nextchar; // ค่าเริ่มต้น CB ขนาดส่วนตัวคงที่ int defaultcharbuffersize = 8192; /*** สตริงตัวคั่นบรรทัด นี่คือค่าของคุณสมบัติ Line.Sparator * ในขณะที่สตรีมถูกสร้างขึ้น * อักขระบรรทัดใหม่ที่ใช้สำหรับวิธีการใหม่ แพลตฟอร์มที่แตกต่างกันมีค่าที่แตกต่างกัน */ สตริงส่วนตัว Lineparator; /*** สร้าง BufferedWriter BW ด้วยขนาด CB เริ่มต้น */ Public BufferedWriter (นักเขียนออก) {สิ่งนี้ (ออก, defaultcharbuffersize); } / ** * สร้าง BR และเริ่มต้นฟิลด์ที่เกี่ยวข้องด้วยขนาด CB ที่ระบุ * / Public BufferedWriter (Writer Out, Int Sz) {super (out); ถ้า (sz <= 0) โยน unlegalargumentException ใหม่ ("ขนาดบัฟเฟอร์ <= 0"); this.out = out; cb = char ใหม่ [sz]; nchars = sz; nextchar = 0; // รับการเป็นตัวแทนของอักขระใหม่ภายใต้แพลตฟอร์มที่แตกต่างกัน lineparator = (สตริง) java.security.accesscontroller.doprivileged (ใหม่ Sun.security.action.aterTpropertyAction ("line.Separator")); } / ** ตรวจพบว่าสตรีมเอาท์พุทอักขระพื้นฐานถูกปิด* / โมฆะส่วนตัวตรวจสอบให้แน่ใจว่า () โยน ioexception {ถ้า (ออก == null) โยน iOexception ใหม่ ("ปิดสตรีม"); } /*** ล้างอักขระที่แคชใน CB ไปยังพื้นฐาน แต่ไม่ล้างตัวละครในรูปแบบพื้นฐาน * และล้าง CB */ void flushbuffer () พ่น IOException {ซิงโครไนซ์ (ล็อค) {uStenOpen (); if (nextchar == 0) return; out.write (cb, 0, nextchar); nextchar = 0;}} /*** เขียนอักขระตัวเดียวไปยัง CB */ โมฆะสาธารณะเขียน (int c) พ่น IOException {ซิงโครไนซ์ (ล็อค) {uSePen (); if (nextchar> = nchars) flushbuffer (); cb [nextchar ++] = (char) c;}} /** * วิธีการขั้นต่ำเล็ก ๆ น้อย ๆ ของเราเองเพื่อหลีกเลี่ยงการโหลด java.lang.math ถ้าเราเรียกใช้ * จากตัวอธิบายไฟล์และเรากำลังพยายามพิมพ์ร่องรอยสแต็ก */ private int min (int a, int b) {ถ้า (a <b) return a; return b; } / *** เขียนความยาวอักขระของเลนจากตัวห้อยออกไปยัง cb* / โมฆะสาธารณะเขียน (ถ่าน cbuf [], int ปิด, int len) โยน ioexception {ซิงโครไนซ์ (ล็อค) {urepen (); if ((ปิด <0) || (ปิด> cbuf.length) || (len <0) || ((ปิด + len)> cbuf.length) || ((ปิด + len) <0)) {โยน indexoutofboundsexception ใหม่ (); } อื่นถ้า (len == 0) {return; } if (len> = nChars) {/* ถ้า len มากกว่าความยาวของ CB ดังนั้นอักขระที่มีอยู่ใน CB และอักขระใน CBUF จะถูกเขียนขึ้นโดยตรงแทนที่จะเขียนถึง CB แล้วเขียนถึงออก */flushbuffer (); out.write (cbuf, ปิด, len); return; } int b = ปิด, t = ปิด + len; ในขณะที่ (b <t) {int d = min (nchars - nextchar, t - b); system.arraycopy (cbuf, b, cb, nextchar, d); b += d; nextchar += d; if (nextchar> = nchars) flushbuffer (); }}} / *** เขียนส่วนหนึ่งของสตริงไปที่ cb* / โมฆะสาธารณะเขียน (สตริง s, int ปิด, int len) พ่น IOException {ซิงโครไนซ์ (ล็อค) {uSePen (); int b = ปิด, t = ปิด + len; ในขณะที่ (b <t) {int d = min (nchars - nextchar, t - b); s.getChars (b, b +d, cb, nextchar); b += d; nextchar += d; ถ้า (nextchar> = nchars) flushbuffer (); }}} /*** เขียนใหม่ */ โมฆะสาธารณะ newline () พ่น IOException {เขียน (lineparator); } / *** รีเฟรชสตรีมนี้และรีเฟรชสตรีมพื้นฐานในเวลาเดียวกัน* / โมฆะสาธารณะฟลัช () พ่น IOException {ซิงโครไนซ์ (ล็อค) {flushbuffer (); out.flush ();}} /*** ปิดสตรีมและทรัพยากรที่วางจำหน่ายที่เกี่ยวข้องกับสตรีมนี้ */ โมฆะสาธารณะปิด () พ่น IOException {ซิงโครไนซ์ (ล็อค) {ถ้า (ออก == null) {return; } ลอง {flushbuffer (); } ในที่สุด {out.close (); ออก = null; cb = null; -4. ตัวอย่างการสาธิต: ใช้ bufferedReader ต่อไปนี้เพื่อใช้การคัดลอกไฟล์ประเภทอักขระ
สอง: bufferedreader
1. บทนำเกี่ยวกับฟังก์ชั่นคลาส:
สตรีมอินพุตอักขระบัฟเฟอร์ฟังก์ชั่นของมันคือการให้ฟังก์ชั่นบัฟเฟอร์สำหรับสตรีมอินพุตอักขระพื้นฐานที่เข้ามา มันจะอ่านอักขระในสตรีมอินพุตอักขระพื้นฐาน (ใน) ลงในบัฟเฟอร์ของตัวเอง (อาร์เรย์อักขระแคชในตัว) จากนั้นโปรแกรมจะเรียกวิธีการอ่านของบัฟเฟอร์รีดเพื่ออ่านอักขระในบัฟเฟอร์ลงในโปรแกรม เมื่ออักขระในบัฟเฟอร์ถูกอ่านตัวบัฟเฟอร์จะอ่านบล็อกข้อมูลถัดไปจากในและเข้าสู่บัฟเฟอร์สำหรับโปรแกรมที่จะอ่านจนกว่าข้อมูลจะอ่าน ประโยชน์ของการทำเช่นนี้คืออันดับแรกมันช่วยปรับปรุงประสิทธิภาพการอ่านและที่สองจะช่วยลดจำนวนการเชื่อมต่อเพื่อเปิดสื่อการจัดเก็บ ด้วยเหตุผลโดยละเอียด BufferedWriter ที่กล่าวถึงด้านล่าง มีวิธีการสำคัญในการเติม () ซึ่งคือการเติมข้อมูลจาก IN และกรอกข้อมูลจากบัฟเฟอร์ทุกครั้งที่ข้อมูลในบัฟเฟอร์อ่านเร็วกว่าที่อ่านจากดิสก์สิบเท่า! นี่คือการปรับปรุงประสิทธิภาพที่น่ากลัวมาก ในเวลาเดียวกันเราไม่สามารถระบุขนาดบัฟเฟอร์ของ bufferedReader โดยไม่ต้องห้าม ท้ายที่สุดมันใช้เวลานานในการอ่านครั้งเดียว ประการที่สองราคาหน่วยความจำค่อนข้างแพง สิ่งที่เราสามารถทำได้คือพยายามค้นหาจุดที่สมเหตุสมผลในนั้น โดยทั่วไปเราไม่ต้องกังวลเกี่ยวกับมันและใช้ขนาดเริ่มต้นของบัฟเฟอร์เมื่อสร้าง bufferedReader
2. บทนำสู่ BufferedReader API:
ตอบ: การสร้างวิธีการบัฟเฟอร์การอ่าน (ตัวอ่าน, int sz) สร้าง bufferedreader ตามขนาดที่ระบุและสตรีมอินพุตอักขระพื้นฐาน BR bufferedReader (ตัวอ่านใน) ใช้ขนาดเริ่มต้นเพื่อสร้างกระแสบัฟเฟอร์ของกระแสเอาต์พุตพื้นฐาน B: วิธีการทั่วไป void ปิด () ปิดสตรีมนี้และปล่อยทรัพยากรทั้งหมดที่เกี่ยวข้องกับเครื่องหมายโมฆะสตรีมนี้ อ่านอักขระ int read () อ่านอักขระตัวเดียวและส่งคืนในรูปแบบจำนวนเต็ม หากการอ่านสิ้นสุดในนั้นจะกลับมา -1 int read (char [] cbuf, int ปิด, int len) อ่านอักขระ len ใน cbuf เริ่มต้นจากการแยกตัวออก, ความยาว len string readline () อ่านเส้นยาวข้าม (ยาว n) ทิ้งอักขระ n ใน cbuf
3. การวิเคราะห์รหัสที่มา
แพ็คเกจ com.chy.io.original.code; นำเข้า java.io.ioException;/*** เพิ่มอาร์เรย์บัฟเฟอร์ตัวละคร CB สำหรับสตรีมอินพุตอักขระพื้นฐาน ปรับปรุงประสิทธิภาพ * @version 1.1, 13/11/17 * @authorandychen */คลาสสาธารณะ BufferedReader ขยายตัวอ่าน {ผู้อ่านส่วนตัวใน; ถ่านส่วนตัว CB []; private int nchars, nextchar; int คงสุดท้ายส่วนตัวไม่ถูกต้อง = -2; int คงสุดท้ายคงที่ไม่ได้ทำเครื่องหมาย = -1; private int markedchar = unmarked; ส่วนตัว int readaheadlimit = 0; /*ใช้ได้เฉพาะเมื่อ markedchar> 0*// ** หากอักขระถัดไปเป็นฟีดบรรทัดให้ข้ามไป*/ บูลีนส่วนตัว skiplf = false; / ** ธง skiplf เมื่อเครื่องหมายถูกตั้งค่า*/ บูลีนส่วนตัว markedskiplf = false; ส่วนตัวคงที่ int defaultcharbuffersize = 8192; INT ส่วนตัวคงที่เริ่มต้น ExpectedLinelength = 80; /*** สร้าง bufferedReader ตามขนาดที่ระบุและสตรีมอินพุตอักขระพื้นฐาน br */ public bufferedreader (reader in, int sz) {super (in); ถ้า (sz <= 0) โยน unlegalargumentexception ใหม่ ("ขนาดบัฟเฟอร์ <= 0"); this.in = in; cb = ถ่านใหม่ [sz]; nextchar = nchars = 0; } / *** ใช้ขนาดเริ่มต้นเพื่อสร้างสตรีมบัฟเฟอร์ของสตรีมเอาต์พุตพื้นฐาน* / บัฟเฟอร์สาธารณะ (ตัวอ่านใน) {สิ่งนี้ (ใน, defaultcharbuffersize); } / ** ตรวจพบว่าสตรีมอินพุตอักขระพื้นฐานในนั้นถูกปิด* / โมฆะส่วนตัว urepen () โยน ioexception {ถ้า (ใน == null) โยน iOexception ใหม่ ("ปิดสตรีม"); } /*** เติมใน CB */ โมฆะส่วนตัวเติม () พ่น IOException {int dst; if (markedchar <= unmarked) {/ *ไม่มีเครื่องหมาย */ dst = 0;} else {/ *ทำเครื่องหมาย */ int delta = nextchar - markedchar; if (delta> = readaheadlimit) {/ * ผ่านขีด จำกัด การอ่านล่วงหน้า: เครื่องหมายโมฆะ */markedChar = ไม่ถูกต้อง; readAheadLimit = 0; dst = 0; } else {if (readAheadLimit <= cb.length) { / * shuffle ในบัฟเฟอร์ปัจจุบัน * / system.arraycopy (cb, markedchar, cb, 0, delta); markedchar = 0; dst = delta;} else { / * reallocate buffer เพื่อรองรับขีด จำกัด การอ่านต่อไป * / char ncb [] = char ใหม่ [readaheadlimit]; System.arrayCopy (CB, MarkedChar, NCB, 0, Delta); CB = NCB; markedchar = 0; dst = delta;} nextchar = nchars = delta; }} int n; do {n = in.read (cb, dst, cb.length - dst);} ในขณะที่ (n == 0); ถ้า (n> 0) {nchars = dst + n; nextchar = dst;}} /*** อ่านอักขระตัวเดียวและกลับเป็นจำนวนเต็ม หากการอ่านสิ้นสุดในนั้นจะกลับมา -1 */ public int read () พ่น ioexception {ซิงโครไนซ์ (ล็อค) {urePen (); สำหรับ (;;) {ถ้า (nextchar> = nChars) {เติม (); if (nextchar> = nchars) return -1;} ถ้า (skiplf) {skiplf = false; if (cb [nextchar] == '/n') {nextchar ++; ดำเนินการต่อ; }} ส่งคืน cb [nextchar ++]; }}} /*** อ่านอักขระ LEN ใน CBUF จากความยาว len เริ่มต้นจากตัวหั่น ตัวละครในบัฟเฟอร์ท้องถิ่น ด้วยวิธีนี้ลำธารบัฟเฟอร์จะหยุดชะงักอย่างไม่เป็นอันตราย */ if (len> = cb.length && markedchar <= unmarked &&! skiplf) {return in.read (cbuf, ปิด, len); } fill ();} ถ้า (nextchar> = nChars) return -1; ถ้า (skiplf) {skiplf = false; if (cb [nextchar] == '/n') {nextchar ++; ถ้า (nextchar> = nchars) เติม (); ถ้า (nextchar> = nchars) return -1; }} int n = math.min (len, nchars - nextchar); system.arraycopy (cb, nextchar, cbuf, ปิด, n); nextchar += n; return n; } / *** อ่านอักขระ LEN ใน CBUF ถึงความยาว len จากดัชนีปิดจากตัวหั่น if ((ปิด <0) || (ปิด> cbuf.length) || (len <0) || ((ปิด + len)> cbuf.length) || ((ปิด + len) <0)) {โยน indexoutofboundsexception ใหม่ (); } อื่นถ้า (len == 0) {return 0; } int n = read1 (cbuf, ปิด, len); ถ้า (n <= 0) ส่งคืน n; ในขณะที่ ((n <len) && in.ready ()) {int n1 = read1 (cbuf, ปิด + n, len - n); ถ้า (n1 <= 0) break; n + = n1; } return n;}} / *** อ่านบรรทัดจากในและละเว้นตัวแบ่งบรรทัด* / string readline (บูลีนไม่รู้ตัว) พ่น IOException {StringBuffer s = null; int startChar; ซิงโครไนซ์ (ล็อค) {uceOpen (); บูลีน omitlf = ไม่รู้ตัว || skiplf; bufferloop: สำหรับ (;;) {ถ้า (nextchar> = nchars) เติม (); ถ้า (nextchar> = nchars) { / * eof * / if (s! = null && s.length ()> 0) ส่งคืน s.toString (); elsereturn null;} boolean eol = false; char c = 0; int i; / * ข้ามสิ่งที่เหลือ '/n' หากจำเป็น */if (omitlf && (cb [nextchar] == '/n')) nextchar ++; skiplf = false; omitlf = false; Charloop: สำหรับ (i = nextchar; i <nchars; i ++) {c = cb [i]; if ((c == '/n') || (c == '/r')) {eol = true; break charloop; }} startchar = nextchar; nextchar = i; if (eol) {string str; if (s == null) {str = สตริงใหม่ (cb, startchar, i - startchar); } else {s.append (cb, startchar, i - startchar); str = s.toString (); } nextchar ++; if (c == '/r') {skiplf = true; } return str;} if (s == null) s = new StringBuffer (defaultExpectedLinelength); s.Append (cb, startchar, i - startchar); }}} / ** * อ่านบรรทัดจากใน, * / สตริงสาธารณะ readline () พ่น IOException {return readline (เท็จ); } / *** ละทิ้งอักขระ n ใน* / สาธารณะยาวข้าม (ยาว n) โยน ioexception {ถ้า (n <0l) {โยน unlegalargumentException ใหม่ ("ข้ามค่าเป็นลบ");} ซิงโครไนซ์ (ล็อค) ยาว r = n; ในขณะที่ (r> 0) {ถ้า (nextchar> = nchars) เติม (); ถ้า (nextchar> = nchars)/ * eof */ break; ถ้า (skiplf) {skiplf = false; if (cb [nextchar] == '/n') {nextchar ++; }} long d = nchars - nextchar; if (r <= d) {nextchar += r; r = 0; break;} else {r -= d; nextchar = nchars;}} return n - r;}} / ** * ตรวจสอบว่า CB ว่างเปล่าหรือว่ามีอักขระที่อ่านได้ในพื้นฐาน * / บูลีนสาธารณะพร้อม () พ่น IOException {ซิงโครไนซ์ (ล็อค) / * * หากจำเป็นต้องข้ามสายใหม่และตัวถ่านถัดไปที่จะอ่าน * เป็นอักขระใหม่ ๆ จากนั้นก็ข้ามไปทันที */ if (skiplf) {/ * โปรดทราบว่า in.ready () จะส่งคืนจริงถ้าและเฉพาะในกรณีต่อไป * อ่านบนสตรีมจะไม่บล็อก */if (nextchar> = nchars && in.ready ()) {fill ();} ถ้า (nextchar <nchars) {ถ้า (cb [nextchar] == '/n') nextchar ++; skiplf = false;}} return (nextchar <nchars) || in.ready ();}} / *** พิจารณาว่าสตรีมนี้รองรับเครื่องหมาย* / public boolean marksupported () {return true; } /*** ทำเครื่องหมายตำแหน่งของสตรีมนี้ในเวลานี้และอนุญาตให้อ่านถึงอักขระ readaheadlimit ก่อนที่การโทรเพื่อรีเซ็ตวิธีการล้มเหลว */ เครื่องหมายโมฆะสาธารณะ (int readaheadlimit) โยน ioexception {ถ้า (readaheadlimit <0) {โยน unlegalargumentexception ใหม่ ("ขีด จำกัด การอ่าน head <0");} ซิงโครไนซ์ (ล็อค) this.readaheadlimit = readaheadlimit; markedChar = nextchar; MarkedSkiplf = skiplf;}} /*** รีเซ็ตตำแหน่งที่ทำเครื่องหมายล่าสุด นั่นคือตัวละครถัดไปจะอ่านจากตำแหน่งที่มีการทำเครื่องหมายล่าสุด */ โมฆะสาธารณะรีเซ็ต () พ่น IOException {ซิงโครไนซ์ (ล็อค) {uSePen (); ถ้า (markedchar <0) โยน iOexception ใหม่ ((markedchar == ไม่ถูกต้อง)? "mark ไม่ถูกต้อง": "สตรีมไม่ได้ทำเครื่องหมาย"); nextchar = markedchar; skiplf = markedskiplf;}} // ปิดสตรีมนี้และปล่อยทรัพยากรทั้งหมดที่เกี่ยวข้องกับกระแสความโมฆะสาธารณะปิด () พ่น IOException {ซิงโครไนซ์ (ล็อค) {ถ้า (ใน == null) คืน; in.close (); ใน = null; cb = null;}}}4. ตัวอย่างการสาธิต:
แพ็คเกจ com.chy.io.original.test; นำเข้า java.io.bufferedreader; นำเข้า java.io.bufferedwriter; นำเข้า java.io.file; นำเข้า java.io.filereader; นำเข้า Java.io.filewriter; {/*** การทดสอบของสองคลาสนี้ที่นี่ค่อนข้างง่ายซึ่งก็คือการห่อสตรีมอักขระตัวอักษรและใช้การคัดลอกไฟล์* หากคุณสนใจคุณสามารถทดสอบประสิทธิภาพขี้เกียจและเพิกเฉยต่อมัน*/โมฆะสาธารณะคงที่ (สตริง [] args) ไฟล์ ("e: //copyoftest.txt"); bufferedreader br = new bufferedreader (filereader ใหม่ (resoucefile)); bufferedWriter bw = bufferedWriter ใหม่ (FileWriter ใหม่ (TargetFile)); char [] CBUF = ใหม่ -1) {bw.write (cbuf, 0, n);} // อย่าลืมรีเฟรชและปิดการไหลมิฉะนั้นทรัพยากรจะไม่ถูกปล่อยออกมาในเวลาหนึ่งมือข้างหนึ่งและในทางกลับกันมันอาจทำให้ข้อมูลสูญเสียถ้า br.close (); bw.flush (); bw.close ();สรุป:
สำหรับ BufferedReader และ BufferedWriter สาระสำคัญคือการเพิ่มฟังก์ชั่นบัฟเฟอร์ไปยังสตรีมอินพุตอักขระพื้นฐานและกระแสเอาต์พุตการอ่านหรือเขียนข้อมูลครั้งแรกในสตรีมพื้นฐานในรูปแบบของกลุ่มการอ่านในแต่ละครั้งแล้วทำงานบนบัฟเฟอร์ สิ่งนี้ไม่เพียง แต่ประสิทธิภาพ แต่ยังช่วยประหยัดทรัพยากร ในที่สุดในโปรแกรมด้วยเหตุผลที่มีประสิทธิภาพควรใช้คลาสทั้งสองนี้สำหรับสตรีมระดับต่ำเพื่อตกแต่งพวกเขาแทนที่จะถือสตรีมและอัปโหลดโดยตรงโดยคิดว่าพวกเขาสามารถรับรู้ได้