Java NIO (อินพุต/เอาท์พุตใหม่) - แพ็คเกจ API อินพุต/เอาท์พุตใหม่ - เปิดตัวใน J2SE 1.4 ในปี 2545 เป้าหมายของ Java NIO คือการปรับปรุงประสิทธิภาพของงานที่เน้น I/O บนแพลตฟอร์ม Java สิบปีต่อมา นักพัฒนา Java จำนวนมากยังคงไม่รู้ว่าจะใช้ NIO อย่างเต็มที่ได้อย่างไร และมีคนเพียงไม่กี่คนที่รู้ว่า API อินพุต/เอาท์พุตที่อัปเดต (NIO.2) เปิดตัวใน Java SE 7 การสนับสนุนที่ใหญ่ที่สุดของ NIO และ NIO.2 ในแพลตฟอร์ม Java คือการปรับปรุงประสิทธิภาพของส่วนประกอบหลักในการพัฒนาแอปพลิเคชัน Java: การประมวลผลอินพุต/เอาท์พุต อย่างไรก็ตาม ไม่มีแพ็คเกจใดมีประโยชน์มากนัก และไม่เหมาะกับทุกสถานการณ์ หากใช้อย่างถูกต้อง Java NIO และ NIO.2 จะสามารถลดเวลาที่ใช้ในการดำเนินการ I/O ทั่วไปบางอย่างได้อย่างมาก นี่คือพลังพิเศษของ NIO และ NIO.2 และในบทความนี้ ผมจะแสดงวิธีใช้งานง่ายๆ 5 วิธี
เปลี่ยนการแจ้งเตือน (เพราะทุกเหตุการณ์ต้องมีผู้ฟัง)
ตัวเลือกและ IO แบบอะซิงโครนัส: การปรับปรุงมัลติเพล็กซ์ผ่านตัวเลือก
ช่อง - คำสัญญาและความเป็นจริง
การทำแผนที่หน่วยความจำ - ใช้เหล็กที่ดีกับใบมีด
การเข้ารหัสอักขระและการค้นหา
ความเป็นมาของ NIO
เหตุใดแพ็คเกจการปรับปรุงที่มีมาประมาณ 10 ปีจึงเป็นแพ็คเกจ I/O ใหม่สำหรับ Java เหตุผลก็คือสำหรับโปรแกรมเมอร์ Java ส่วนใหญ่ การดำเนินการ I/O พื้นฐานก็เพียงพอแล้ว ในการทำงานประจำวัน Java Developer ส่วนใหญ่ไม่จำเป็นต้องเรียนรู้ NIO ก้าวไปอีกขั้น NIO เป็นมากกว่าแพ็คเกจการปรับปรุงประสิทธิภาพ แต่เป็นการรวบรวมฟังก์ชันต่างๆ ที่เกี่ยวข้องกับ Java I/O แทน NIO ประสบความสำเร็จในการปรับปรุงประสิทธิภาพโดยการทำให้ประสิทธิภาพของแอปพลิเคชัน Java "ใกล้ชิดกับสาระสำคัญมากขึ้น" ซึ่งหมายความว่า API ของ NIO และ NIO.2 จะเปิดเผยทางเข้าสู่การทำงานของระบบระดับต่ำ ราคาของ NIO คือแม้ว่าจะให้ความสามารถในการควบคุม I/O ที่มีประสิทธิภาพมากกว่า แต่ก็ยังต้องการให้เราใช้และฝึกฝนอย่างระมัดระวังมากกว่าการเขียนโปรแกรม I/O พื้นฐาน คุณสมบัติอีกประการหนึ่งของ NIO คือการมุ่งเน้นไปที่ความหมายของแอปพลิเคชัน ซึ่งเราจะเห็นในแบบฝึกหัดต่อไปนี้
เริ่มเรียนรู้ NIO และ NIO.2
มีเอกสารอ้างอิงมากมายสำหรับ NIO - ลิงก์ที่เลือกบางส่วนในเอกสารอ้างอิง หากต้องการเรียนรู้ NIO และ NIO.2 เอกสารประกอบ Java 2 SDK Standard Edition (SE) และเอกสารประกอบ Java SE 7 เป็นสิ่งที่ขาดไม่ได้ หากต้องการใช้โค้ดในบทความนี้ คุณต้องใช้ JDK 7 ขึ้นไป
สำหรับนักพัฒนาหลายคน ครั้งแรกที่พวกเขาพบ NIO อาจเป็นตอนที่ดูแลแอปพลิเคชัน: แอปพลิเคชันที่ทำงานช้าลงเรื่อยๆ ดังนั้นบางคนจึงแนะนำให้ใช้ NIO เพื่อปรับปรุงความเร็วในการตอบสนอง NIO มีความโดดเด่นในเรื่องการปรับปรุงประสิทธิภาพของแอปพลิเคชัน แต่ผลลัพธ์ที่เฉพาะเจาะจงนั้นขึ้นอยู่กับระบบพื้นฐาน (โปรดทราบว่า NIO ขึ้นอยู่กับแพลตฟอร์ม) หากนี่เป็นครั้งแรกที่คุณใช้ NIO คุณจะต้องชั่งน้ำหนักอย่างระมัดระวัง คุณจะพบว่าความสามารถของ NIO ในการปรับปรุงประสิทธิภาพไม่เพียงแต่ขึ้นอยู่กับ OS เท่านั้น แต่ยังขึ้นอยู่กับ JVM ที่คุณใช้ บริบทเสมือนของโฮสต์ คุณลักษณะของที่เก็บข้อมูลขนาดใหญ่ และแม้แต่ข้อมูล ดังนั้นงานวัดประสิทธิภาพจึงทำได้ค่อนข้างยาก โดยเฉพาะอย่างยิ่งเมื่อระบบของคุณมีสภาพแวดล้อมการใช้งานแบบพกพา คุณต้องให้ความสนใจเป็นพิเศษ
หลังจากทำความเข้าใจเนื้อหาข้างต้นแล้ว เราก็ไม่ต้องกังวลอีกต่อไป ตอนนี้เรามาสัมผัสประสบการณ์การทำงานที่สำคัญทั้ง 5 ประการของ NIO และ NIO.2 กันดีกว่า
1. เปลี่ยนการแจ้งเตือน (เพราะแต่ละเหตุการณ์ต้องมีผู้ฟัง)
ข้อกังวลทั่วไปในหมู่นักพัฒนาที่สนใจ NIO และ NIO.2 คือประสิทธิภาพของแอปพลิเคชัน Java จากประสบการณ์ของฉัน ตัวแจ้งเตือนการเปลี่ยนแปลงไฟล์ใน NIO.2 เป็นคุณสมบัติที่น่าสนใจที่สุด (และประเมินต่ำเกินไป) ของ API อินพุต/เอาท์พุตใหม่
แอปพลิเคชันระดับองค์กรจำนวนมากต้องการการประมวลผลพิเศษในสถานการณ์ต่อไปนี้:
เมื่อไฟล์ถูกอัพโหลดไปยังโฟลเดอร์ FTP
เมื่อมีการแก้ไขคำจำกัดความในการกำหนดค่า
เมื่ออัพโหลดเอกสารร่างแล้ว
เมื่อเหตุการณ์ระบบไฟล์อื่นเกิดขึ้น
ทั้งหมดนี้คือตัวอย่างการแจ้งเตือนการเปลี่ยนแปลงหรือการตอบกลับการเปลี่ยนแปลง ใน Java เวอร์ชันก่อนหน้า (และภาษาอื่นๆ) การโพลเป็นวิธีที่ดีที่สุดในการตรวจหาเหตุการณ์การเปลี่ยนแปลงเหล่านี้ การโพลเป็นการวนซ้ำแบบพิเศษ: ตรวจสอบระบบไฟล์หรืออ็อบเจ็กต์อื่น ๆ และเปรียบเทียบกับสถานะก่อนหน้า หากไม่มีการเปลี่ยนแปลง ให้ตรวจสอบต่อไปหลังจากช่วงเวลาประมาณสองสามร้อยมิลลิวินาทีหรือ 10 วินาที สิ่งนี้ดำเนินต่อไปในวงวนไม่สิ้นสุด
NIO.2 มอบวิธีที่ดีกว่าในการตรวจจับการเปลี่ยนแปลง รายการที่ 1 เป็นตัวอย่างง่ายๆ
รายการ 1. เปลี่ยนกลไกการแจ้งเตือนใน NIO.2
คัดลอกรหัสรหัสดังต่อไปนี้:
นำเข้า java.nio.file.attribute.*;
importjava.io.*;
importjava.util.*;
importjava.nio.file.Path;
importjava.nio.file.Paths;
importjava.nio.file.StandardWatchEventKinds;
importjava.nio.file.WatchEvent;
importjava.nio.file.WatchKey;
importjava.nio.file.WatchService;
importjava.util.List;
publicclassWatcher{
publicstaticvoidmain (สตริง [] args) {
Paththis_dir=Paths.get(".");
System.out.println("กำลังดูไดเรกทอรีปัจจุบัน...");
พยายาม{
WatchServicewatcher=this_dir.getFileSystem().newWatchService();
this_dir.register (ผู้เฝ้าดู StandardWatchEventKinds.ENTRY_CREATE);
WatchKeywatckKey=watcher.take();
รายการ <WatchEvent<<64;>>events=watckKey.pollEvents();
สำหรับ (WatchEventevent: กิจกรรม) {
System.out.println("Someonejustcreatedthefile'"+event.context().toString()+"'");
-
} จับ (ยกเว้น) {
System.out.println("ข้อผิดพลาด:"+e.toString());
-
-
-
รวบรวมโค้ดนี้และดำเนินการจากบรรทัดคำสั่ง ในไดเร็กทอรีเดียวกัน ให้สร้างไฟล์ใหม่ เช่น รันคำสั่ง touchexample หรือ copyWatcher.classexample คุณจะเห็นข้อความแจ้งเตือนการเปลี่ยนแปลงต่อไปนี้:
มีคนเพิ่งสร้าง Thefiel'example1'
ตัวอย่างง่ายๆ นี้แสดงวิธีเริ่มใช้งานฟังก์ชัน JavaNIO ในเวลาเดียวกัน ยังแนะนำคลาส NIO.2 Watcher ซึ่งตรงกว่าและใช้งานง่ายกว่ารูปแบบการโพลใน I/O ดั้งเดิม
ระวังการสะกดผิด
เมื่อคุณคัดลอกโค้ดจากบทความนี้ โปรดระวังการสะกดผิด ตัวอย่างเช่น อ็อบเจ็กต์ StandardWatchEventKinds ในรายการ 1 อยู่ในรูปแบบพหูพจน์ แม้แต่ในเอกสาร Java.net ก็สะกดผิด
เคล็ดลับ
กลไกการแจ้งเตือนใน NIO นั้นใช้งานง่ายกว่าวิธีการสำรวจแบบเก่า ซึ่งจะกระตุ้นให้คุณเพิกเฉยต่อการวิเคราะห์ข้อกำหนดเฉพาะโดยละเอียด เมื่อคุณใช้ Listener เป็นครั้งแรก คุณต้องพิจารณาความหมายของแนวคิดที่คุณใช้อย่างรอบคอบ ตัวอย่างเช่น การรู้ว่าการเปลี่ยนแปลงจะสิ้นสุดเมื่อใดมีความสำคัญมากกว่าการรู้ว่าเมื่อใดจะเริ่มต้น การวิเคราะห์ประเภทนี้จะต้องใช้ความระมัดระวังเป็นอย่างยิ่ง โดยเฉพาะในสถานการณ์ทั่วไป เช่น การย้ายโฟลเดอร์ FTP NIO เป็นแพ็คเกจที่ทรงพลังมาก แต่ก็มี "gotchas" บางอย่างที่ละเอียดอ่อนซึ่งอาจทำให้เกิดความสับสนสำหรับผู้ที่ไม่คุ้นเคย
2. ตัวเลือกและ IO แบบอะซิงโครนัส: ปรับปรุงมัลติเพล็กซ์ผ่านตัวเลือก
โดยทั่วไปผู้มาใหม่ของ NIO จะเชื่อมโยงกับ "อินพุต/เอาท์พุตที่ไม่ปิดกั้น" NIO เป็นมากกว่า I/O ที่ไม่บล็อก แต่การรับรู้นี้ไม่ได้ผิดทั้งหมด: I/O พื้นฐานของ Java กำลังบล็อก I/O - หมายความว่าจะรอจนกว่าการดำเนินการจะเสร็จสิ้น - อย่างไรก็ตาม I/O แบบไม่บล็อกหรืออะซิงโครนัส เป็นคุณสมบัติที่ใช้บ่อยที่สุดของ NIO ไม่ใช่ NIO ทั้งหมด
I/O ที่ไม่ปิดกั้นของ NIO ขับเคลื่อนด้วยเหตุการณ์และแสดงให้เห็นในตัวอย่างการฟังระบบไฟล์ในรายการที่ 1 นี่หมายถึงการกำหนดตัวเลือก (การเรียกกลับหรือตัวฟัง) สำหรับช่อง I/O จากนั้นโปรแกรมจึงสามารถทำงานต่อไปได้ เมื่อมีเหตุการณ์เกิดขึ้นกับตัวเลือกนี้ - เช่น รับบรรทัดอินพุต - ตัวเลือกจะ "ปลุก" และดำเนินการ ทั้งหมดนี้ดำเนินการผ่านเธรดเดียว ซึ่งแตกต่างจาก I/O มาตรฐานของ Java อย่างมาก
รายการ 2 แสดงโปรแกรมเครือข่ายหลายพอร์ต echo-er ที่ใช้งานโดยใช้ตัวเลือกของ NIO นี่เป็นโปรแกรมขนาดเล็กที่สร้างโดย Greg Travis ในปี 2003 (อ้างอิงถึงรายการทรัพยากร) ระบบที่คล้าย Unix และ Unix ได้ใช้ตัวเลือกที่มีประสิทธิภาพมาเป็นเวลานาน ซึ่งเป็นแบบจำลองอ้างอิงที่ดีสำหรับโมเดลการเขียนโปรแกรมประสิทธิภาพสูงในเครือข่าย Java
รายการ 2.ตัวเลือก NIO
คัดลอกรหัสรหัสดังต่อไปนี้:
importjava.io.*;
importjava.net.*;
importjava.nio.*;
importjava.nio.channels.*;
importjava.util.*;
publicclassMultiPortEcho
-
พอร์ตส่วนตัว [];
privateByteBufferechoBuffer=ByteBuffer.allocate(1024);
publicMultiPortEcho (intports []) พ่น IOException {
นี้.พอร์ต=พอร์ต;
configuration_selector();
-
privatevoidconfigure_selector()พ่นIOException{
//Createanewselector
Selectorselector=Selector.open();
// Openalisteneroneachport, andregistereachone
//ด้วยตัวเลือก
สำหรับ(inti=0;i<ports.length;++i){
ServerSocketChannelssc=ServerSocketChannel.open();
ssc.configureBlocking (เท็จ);
ServerSocketss=ssc.socket();
InetSocketAddressaddress=newInetSocketAddress(พอร์ต[i]);
ss.bind(ที่อยู่);
SelectionKeykey=ssc.register(ตัวเลือก,SelectionKey.OP_ACCEPT);
System.out.println("Goingtolistenon"+พอร์ต[i]);
-
ในขณะที่ (จริง) {
intnum=selector.select();
SetelectedKeys=selector.selectedKeys();
Iteratorit=selectedKeys.iterator();
ในขณะที่(it.hasNext()){
SelectionKeykey=(SelectionKey)it.next();
ถ้า((key.readyOps()&SelectionKey.OP_ACCEPT)
==SelectionKey.OP_ACCEPT){
//ยอมรับการเชื่อมต่อใหม่
ServerSocketChannelssc=(ServerSocketChannel)key.channel();
SocketChannelsc=ssc.ยอมรับ();
sc.configureBlocking (เท็จ);
//เพิ่มการเชื่อมต่อใหม่ให้กับตัวเลือก
SelectionKeynewKey=sc.register(ตัวเลือก,SelectionKey.OP_READ);
มัน.remove();
System.out.println("Gotconnectionfrom"+sc);
}elseif((key.readyOps()&SelectionKey.OP_READ)
==SelectionKey.OP_READ){
//อ่านข้อมูล
SocketChannelsc=(SocketChannel)key.channel();
//เอคโคดาต้า
intbytesEchoed=0;
ในขณะที่ (จริง) {
echoBuffer.clear();
intnumber_of_bytes=sc.read(echoBuffer);
ถ้า(number_of_bytes<=0){
หยุดพัก;
-
echoBuffer.flip();
sc.write(echoBuffer);
ไบต์ Echoed+=number_of_bytes;
-
System.out.println("สะท้อน"+bytesEchoed+"จาก"+sc);
มัน.remove();
-
-
-
-
staticpublicvoidmain (Stringargs []) พ่นข้อยกเว้น {
ถ้า(args.length<=0){
System.err.println("การใช้งาน:javaMultiPortEchoport[พอร์ตพอร์ต...]");
ระบบ.ออก(1);
-
intports[]=newint[args.length];
สำหรับ(inti=0;i<args.length;++i){
พอร์ต [i] = Integer.parseInt (args [i]);
-
ใหม่MultiPortEcho (พอร์ต);
-
-
คอมไพล์โค้ดนี้และเริ่มต้นด้วยคำสั่งที่คล้ายกับ javaMultiPortEcho80058006 เมื่อโปรแกรมนี้ทำงานสำเร็จ ให้เริ่มเทลเน็ตหรือโปรแกรมจำลองเทอร์มินัลอื่นๆ เพื่อเชื่อมต่อกับอินเทอร์เฟซ 8005 และ 8006 คุณจะเห็นว่าโปรแกรมนี้สะท้อนอักขระทั้งหมดที่ได้รับ และดำเนินการผ่านเธรด Java
3. Passage: คำสัญญาและความเป็นจริง
ใน NIO ช่องสามารถเป็นตัวแทนของวัตถุใดๆ ที่สามารถอ่านและเขียนได้ บทบาทของมันคือการจัดหาสิ่งที่เป็นนามธรรมสำหรับไฟล์และซ็อกเก็ต ช่อง NIO สนับสนุนชุดวิธีการที่สอดคล้องกัน ดังนั้นคุณจึงไม่จำเป็นต้องให้ความสนใจเป็นพิเศษกับออบเจ็กต์ต่างๆ เมื่อเข้ารหัส ไม่ว่าจะเป็นเอาต์พุตมาตรฐาน การเชื่อมต่อเครือข่าย หรือช่องสัญญาณที่ใช้งานอยู่ คุณลักษณะของช่องสัญญาณนี้สืบทอดมาจากสตรีมใน I/O พื้นฐานของ Java สตรีมจัดให้มีการบล็อก IO ช่องรองรับ I/O แบบอะซิงโครนัส
มักแนะนำให้ใช้ NIO เนื่องจากประสิทธิภาพสูง แต่มีความแม่นยำมากกว่าสำหรับเวลาตอบสนองที่รวดเร็ว ในบางสถานการณ์ ประสิทธิภาพของ NIO นั้นแย่กว่า Java I/O พื้นฐาน ตัวอย่างเช่น สำหรับการอ่านและเขียนไฟล์ขนาดเล็กตามลำดับอย่างง่าย ประสิทธิภาพที่ได้รับจากการสตรีมอาจเร็วกว่าการใช้การเข้ารหัสตามช่องทางตามเหตุการณ์ที่สอดคล้องกันสองถึงสามเท่า ในเวลาเดียวกัน ช่องสัญญาณที่ไม่ใช่มัลติเพล็กซ์ - นั่นคือ ช่องแยกต่อเธรด - จะช้ากว่าหลายช่องสัญญาณที่ลงทะเบียนตัวเลือกในเธรดเดียวกัน
ตอนนี้เมื่อคุณกำลังพิจารณาว่าจะใช้สตรีมหรือช่อง ลองถามตัวเองด้วยคำถามต่อไปนี้:
คุณต้องอ่านและเขียนออบเจ็กต์ I/O จำนวนเท่าใด
อ็อบเจ็กต์ I/O ที่แตกต่างกันเรียงลำดับกันหรือจำเป็นต้องเกิดขึ้นพร้อมกันทั้งหมดหรือไม่
ออบเจ็กต์ I/O ของคุณจำเป็นต้องคงอยู่ในช่วงเวลาสั้นๆ หรือตลอดอายุการใช้งานของกระบวนการของคุณหรือไม่?
I/O ของคุณเหมาะสำหรับการประมวลผลในเธรดเดียวหรือหลายเธรดหรือไม่?
การสื่อสารเครือข่ายและ I/O ภายในมีลักษณะเหมือนกัน หรือมีรูปแบบที่แตกต่างกันหรือไม่
การวิเคราะห์ดังกล่าวเป็นแนวปฏิบัติที่ดีที่สุดในการตัดสินใจว่าจะใช้สตรีมหรือช่องทาง ข้อควรจำ: NIO และ NIO.2 ไม่ใช่การแทนที่ I/O พื้นฐาน แต่เป็นส่วนเสริม
4. การทำแผนที่หน่วยความจำ - ใช้เหล็กที่ดีกับใบมีด
การปรับปรุงประสิทธิภาพที่สำคัญที่สุดใน NIO คือการแมปหน่วยความจำ การแมปหน่วยความจำเป็นบริการระดับระบบที่ถือว่าส่วนของไฟล์ที่ใช้ในโปรแกรมเป็นหน่วยความจำ
การทำแผนที่หน่วยความจำมีผลกระทบที่อาจเกิดขึ้นได้มากมาย มากกว่าที่ฉันสามารถให้ได้ที่นี่ ในระดับที่สูงขึ้น จะทำให้ประสิทธิภาพ I/O ของการเข้าถึงไฟล์มีความเร็วถึงความเร็วของการเข้าถึงหน่วยความจำ การเข้าถึงหน่วยความจำมักจะมีความสำคัญเร็วกว่าการเข้าถึงไฟล์ รายการ 3 เป็นตัวอย่างง่ายๆ ของแผนที่หน่วยความจำ NIO
รายการ 3 การแมปหน่วยความจำใน NIO
คัดลอกรหัสรหัสดังต่อไปนี้:
importjava.io.RandomAccessFile;
importjava.nio.MappedByteBuffer;
importjava.nio.channels.FileChannel;
publicclassmem_map_example{
privatestaticintmem_map_size=20*1024*1024;
privatestaticStringfn = "example_memory_mapped_file.txt";
publicstaticvoidmain (สตริง [] args) พ่นข้อยกเว้น {
RandomAccessFilememoryMappedFile=newRandomAccessFile(fn,"rw");
//Mappingafileintomemory
MappedByteBufferout=memoryMappedFile.getChannel().map(FileChannel.MapMode.READ_WRITE,0,mem_map_size);
//เขียนลงใน MemoryMappedFile
สำหรับ(inti=0;i<mem_map_size;i++){
out.put((ไบต์)'A');
-
System.out.println("ไฟล์'"+fn+"'isnow"+Integer.toString(mem_map_size)+"bytesfull.");
//Readfrommemory-mappedfile.
สำหรับ(inti=0;i<30;i++){
System.out.print((ถ่าน)out.get(i));
-
System.out.println("/nReadingfrommemory-mappedfile'"+fn+"'iscomplete.");
-
-
ในรายการ 3 ตัวอย่างง่ายๆ นี้สร้างไฟล์ขนาด 20M example_memory_mapped_file.txt เติมด้วยอักขระ A จากนั้นอ่าน 30 ไบต์แรก ในการใช้งานจริง การแมปหน่วยความจำไม่เพียงแต่ช่วยเพิ่มความเร็วดิบของ I/O เท่านั้น แต่ยังช่วยให้โปรแกรมอ่านและตัวเขียนหลายตัวสามารถประมวลผลไฟล์อิมเมจเดียวกันในเวลาเดียวกันได้ เทคโนโลยีนี้ทรงพลังแต่ก็เป็นอันตรายเช่นกัน แต่หากใช้อย่างถูกต้อง มันจะเพิ่มความเร็ว IO ของคุณหลายครั้ง ดังที่เราทุกคนทราบกันดีว่าการดำเนินการซื้อขายใน Wall Street ใช้เทคโนโลยีการทำแผนที่หน่วยความจำเพื่อให้ได้เปรียบในไม่กี่วินาทีหรือแม้แต่มิลลิวินาที
5.การเข้ารหัสตัวอักษรและการค้นหา
คุณสมบัติสุดท้ายของ NIO ที่ฉันต้องการอธิบายในบทความนี้คือชุดอักขระ ซึ่งเป็นแพ็คเกจที่ใช้ในการแปลงการเข้ารหัสอักขระต่างๆ ก่อน NIO นั้น Java ได้ใช้ฟังก์ชันการทำงานเดียวกันส่วนใหญ่ที่มีอยู่แล้วภายในผ่านเมธอด getByte ชุดอักขระได้รับความนิยมเนื่องจากมีความยืดหยุ่นมากกว่า getBytes และสามารถนำไปใช้ในระดับที่ต่ำกว่า ซึ่งส่งผลให้ประสิทธิภาพดีขึ้น สิ่งนี้มีประโยชน์มากยิ่งขึ้นสำหรับการค้นหาภาษาที่ไม่ใช่ภาษาอังกฤษที่มีความอ่อนไหวต่อการเข้ารหัส การเรียงลำดับ และฟีเจอร์ภาษาอื่นๆ
รายการ 4 แสดงตัวอย่างการแปลงอักขระ Unicode ในภาษา Java เป็นภาษาละติน-1
รายการ 4.ตัวละครใน NIO
คัดลอกรหัสรหัสดังต่อไปนี้:
Stringsome_string="ThisisastringthatJavanativelystoresUnicode";
Charsetlatin1_charset=Charset.forName("ISO-8859-1");
CharsetEncodelatin1_encoder=charset.newEncoder();
ByteBufferlatin1_bbuf=latin1_encoder.encode(CharBuffer.wrap(some_string));
โปรดทราบว่าชุดอักขระและช่องสัญญาณได้รับการออกแบบเพื่อใช้ร่วมกัน เพื่อให้โปรแกรมสามารถทำงานได้ตามปกติเมื่อมีการประสานการแมปหน่วยความจำ, I/O แบบอะซิงโครนัส และการแปลงการเข้ารหัส
สรุป: แน่นอนว่ายังมีอะไรให้รู้อีกมาก
วัตถุประสงค์ของบทความนี้คือเพื่อให้นักพัฒนา Java คุ้นเคยกับฟีเจอร์ที่สำคัญที่สุด (และมีประโยชน์) ใน NIO และ NIO.2 คุณสามารถใช้รากฐานที่กำหนดโดยตัวอย่างเหล่านี้เพื่อทำความเข้าใจวิธีการอื่นๆ ของ NIO ตัวอย่างเช่น ความรู้ที่คุณเรียนรู้เกี่ยวกับช่องสัญญาณสามารถช่วยให้คุณเข้าใจการประมวลผลลิงก์สัญลักษณ์ในระบบไฟล์ในเส้นทางของ NIO คุณยังสามารถอ้างถึงรายการทรัพยากรที่ฉันให้ในภายหลังได้ ซึ่งมีเอกสารบางส่วนสำหรับการศึกษาเชิงลึกเกี่ยวกับ I/O API ใหม่ของ Java