คำอธิบายโดยละเอียดเกี่ยวกับการใช้งานการเข้ารหัสและถอดรหัสอักขระ Java

แพ็คเกจ com.ronsoft.books.nio.charset;

นำเข้า java.nio.charset.Charset;
นำเข้า java.nio.ByteBuffer;

-
* ทดสอบการเข้ารหัสอักขระ เรียกใช้สตริงอินพุตเดียวกันซึ่งมีบางส่วน
* อักขระที่ไม่ใช่ ASCII ผ่านตัวเข้ารหัส Charset หลายตัวและดัมพ์เลขฐานสิบหกออก
* ค่าของลำดับไบต์ผลลัพธ์
-
* @ผู้เขียนรอน ฮิตเชนส์ ([email protected])
-
EncodeTest คลาสสาธารณะ {
โมฆะคงที่สาธารณะ main (String [] argv) พ่นข้อยกเว้น {
// นี่คือลำดับอักขระที่จะเข้ารหัส
อินพุตสตริง = "/u00bfMa/u00f1ana?";
// รายการชุดอักขระที่จะเข้ารหัส
สตริง [] charsetNames = { "US-ASCII", "ISO-8859-1", "UTF-8",
"UTF-16BE", "UTF-16LE", "UTF-16" // , "X-ROT13"
-
สำหรับ (int i = 0; i < charsetNames.length; i++) {
doEncode(Charset.forName(charsetNames[i]), อินพุต);
-
-

-
* สำหรับชุดอักขระและสตริงอินพุตที่กำหนด ให้เข้ารหัสอักขระและพิมพ์ออกมา
* ผลลัพธ์การเข้ารหัสไบต์ในรูปแบบที่อ่านได้
-
doEncode โมฆะคงที่ส่วนตัว (ชุดอักขระ cs, อินพุตสตริง) {
ByteBuffer bb = cs.encode (อินพุต);
System.out.println("ชุดอักขระ: " + cs.name());
System.out.println(" อินพุต: " + อินพุต);
System.out.println("เข้ารหัส: ");
สำหรับ (int i = 0; bb.hasRemaining (); i ++) {
int b = bb.get();
int ival = ((int) b) & 0xff;
ถ่าน c = (ถ่าน) ival;
// จัดแนวตารางให้สวย
ถ้า (ฉัน < 10)
System.out.print(" ");
// พิมพ์หมายเลขดัชนี
System.out.print(" " + i + ": ");
// เอาท์พุตที่มีรูปแบบดีกว่านี้กำลังจะมาในสักวันหนึ่ง...
ถ้า (อิล < 16)
System.out.print("0");
// พิมพ์ค่าฐานสิบหกของไบต์
System.out.print(Integer.toHexString(ival));
// ถ้าไบต์น่าจะเป็นค่าของ a
//พิมพ์ตัวอักษรได้ไม่รับประกันครับ
//มันจะเป็น.
ถ้า (Character.isWhitespace(c) || ​​​​Character.isISOControl(c)) {
System.out.println("");
} อื่น {
System.out.println(" (" + c + ")");
-
-
System.out.println("");
-
-

ชุดอักขระ: ISO-8859-1
อินพุต: ?Ma?ana?
เข้ารหัส:
00:20
1: เป็นแฟนกัน(?)
2: 4d (ม)
3:61(ก)
4: f1 (?)
5:61(ก)
6: 6e(น)
7:61(ก)
8: 3f (?)

ชุดอักขระ: UTF-8
อินพุต: ?Ma?ana?
เข้ารหัส:
00:20
1: c2 (?)
2: เป็นแฟนกัน(?)
3: 4d (ม)
4:61(ก)
5: c3 (?)
6: b1 (±)
7:61(ก)
8: 6e(น)
9:61(ก)
10: 3f (?)

ชุดอักขระ: UTF-16BE
อินพุต: ?Ma?ana?
เข้ารหัส:
00:00 น
1:20
14:00 น
3: เป็นแฟนกัน(?)
16:00 น
5: 4d (ม)
6:00 น
7:61(ก)
8:00 น
9: f1 (?)
10:00 น
11:61(ก)
12:00 น
13: 6e(น)
14:00 น
15: 61 (ก)
16:00 น
17: 3f (?)

ชุดอักขระ: UTF-16LE
อินพุต: ?Ma?ana?
เข้ารหัส:
00:20
13:00 น
2: เป็นแฟนกัน(?)
15:00 น
4: 4d (ม)
05:00 น
6:61(ก)
07:00 น
8: f1 (?)
09:00 น
10:61(ก)
11:00 น
12: 6e(น)
13:00 น
14: 61 (ก)
15:00 น
16: 3f (?)
17:00 น

ชุดอักขระ: UTF-16
อินพุต: ?Ma?ana?
เข้ารหัส:
0: เฟ (?)
1: เอฟ (?)
14:00 น
3:20
16:00 น
5: เป็นแฟนกัน(?)
6:00 น
7: 4d (ม)
8:00 น
9:61(ก)
10:00 น
11: f1 (?)
12:00 น
13: 61 (ก)
14:00 น
15: 6e(น)
16:00 น
17: 61 (ก)
18:00 น
19: 3f (?)

แพ็คเกจ java.nio.charset;
Charset คลาสนามธรรมสาธารณะนำไปใช้เปรียบเทียบได้
-
รองรับบูลีนคงที่สาธารณะ (String charsetName)
Charset สาธารณะคงที่ forName (String charsetName)
SortedMap สาธารณะแบบคงที่ availableCharsets ()
ชื่อสตริงสุดท้ายสาธารณะ ()
นามแฝงชุดสุดท้ายสาธารณะ ()
สตริงสาธารณะ displayName()
สตริงสาธารณะ displayName (สถานที่เกิดเหตุ)
บูลีนสุดท้ายสาธารณะ isRegistered()
บูลีนสาธารณะ canEncode()
CharsetEncoder นามธรรมสาธารณะ newEncoder ();
การเข้ารหัส ByteBuffer สุดท้ายสาธารณะ (CharBuffer cb)
การเข้ารหัส ByteBuffer สุดท้ายสาธารณะ (String str)
CharsetDecoder นามธรรมสาธารณะ newDecoder ();
การถอดรหัส CharBuffer สุดท้ายสาธารณะ (ByteBuffer bb)
บูลีนนามธรรมสาธารณะประกอบด้วย (Charset cs);
บูลีนสุดท้ายสาธารณะเท่ากับ (Object ob)
int สาธารณะสุดท้าย comparisonTo (Object ob)
hashCode int int สาธารณะสุดท้าย ()
สตริงสุดท้ายสาธารณะ toString()
-

Charset คลาสนามธรรมสาธารณะนำไปใช้เปรียบเทียบได้
-
// นี่เป็นรายการ API บางส่วน
บูลีนนามธรรมสาธารณะประกอบด้วย (Charset cs);
บูลีนสุดท้ายสาธารณะเท่ากับ (Object ob)
int สาธารณะสุดท้าย comparisonTo (Object ob)
hashCode int int สาธารณะสุดท้าย ()
สตริงสุดท้ายสาธารณะ toString()
-

แพ็คเกจ java.nio.charset;
CharsetEncoder คลาสนามธรรมสาธารณะ
-
// นี่เป็นรายการ API บางส่วน
บูลีนสาธารณะ canEncode (ถ่าน c)
บูลีนสาธารณะ canEncode (CharSequence cs)
-

แพ็คเกจ java.nio.charset;
CoderResult ระดับสาธารณะ {
CoderResult OVERFLOW สุดท้ายแบบคงที่สาธารณะ
CoderResult สุดท้ายแบบคงที่สาธารณะ UNDERFLOW
บูลีนสาธารณะ isUnderflow()
isOverflow บูลีนสาธารณะ ()
<span style="white-space:pre"> </span>บูลีนสาธารณะ isError()
บูลีนสาธารณะมีรูปแบบไม่ถูกต้อง ()
บูลีนสาธารณะ isUnmappable()
ความยาว int สาธารณะ ()
CoderResult แบบคงที่สาธารณะมีรูปแบบไม่ถูกต้อง ForLength (ความยาว int)
CoderResult คงที่สาธารณะ unmappableForLength (ความยาว int)
<span style="white-space:pre"> </span>public void ThrowException() พ่น CharacterCodingException
-

แพ็คเกจ java.nio.charset;
CharsetDecoder คลาสนามธรรมสาธารณะ
-
// นี่เป็นรายการ API บางส่วน
การรีเซ็ต CharsetDecoder สุดท้ายสาธารณะ ()
ถอดรหัส CharBuffer สุดท้ายสาธารณะ (ByteBuffer ใน)
พ่น CharacterCodingException
ถอดรหัส CoderResult สุดท้ายสาธารณะ (ByteBuffer ใน, CharBuffer ออก,
บูลีน endOfInput)
ล้าง CoderResult สาธารณะขั้นสุดท้าย (CharBuffer ออก)
-

แพ็คเกจ com.ronsoft.books.nio.charset;

นำเข้า java.nio.*;
นำเข้า java.nio.charset.*;
นำเข้า java.nio.channels.*;
นำเข้า java.io.*;

-
* ทดสอบการถอดรหัสชุดอักขระ
-
* @ผู้เขียนรอน ฮิตเชนส์ ([email protected])
-
CharsetDecode คลาสสาธารณะ {
-
* ทดสอบการถอดรหัสชุดอักขระในกรณีทั่วไป การตรวจจับและการจัดการบัฟเฟอร์
* ต่ำกว่า/ล้น และล้างสถานะตัวถอดรหัสเมื่อสิ้นสุดโค้ดนี้
* อ่านจาก stdin และถอดรหัสสตรีมไบต์ที่เข้ารหัส ASCII เป็นตัวอักษร
* ตัวอักษรที่ถอดรหัสถูกเขียนถึง stdout นี่เป็น 'cat' ที่มีประสิทธิภาพ
* อินพุตไฟล์ ASCII แต่การเข้ารหัสชุดอักขระอื่นสามารถใช้งานได้ง่ายๆ
* ระบุบนบรรทัดคำสั่ง
-
โมฆะคงที่สาธารณะ main (String [] argv) พ่น IOException {
// ชุดอักขระเริ่มต้นคือ ASCII มาตรฐาน
ชุดอักขระสตริง = "ISO-8859-1";
// สามารถระบุชื่อชุดอักขระบนบรรทัดคำสั่งได้
ถ้า (ความยาว argv. > 0) {
ชื่ออักขระ = argv[0];
-
// พันช่องรอบ stdin, พันช่องรอบ stdout,
// ค้นหา Charset ที่มีชื่อแล้วส่งต่อไปยังวิธี deco de
// หากชุดอักขระที่ระบุชื่อไม่ถูกต้อง ถือเป็นข้อยกเว้นประเภท
// UnsupportedCharsetException จะถูกส่งออกไป
decodeChannel (Channels.newChannel (System.in), OutputStreamWriter ใหม่ (
System.out), Charset.forName(charsetName));
-

-
* วิธีการคงที่วัตถุประสงค์ทั่วไปซึ่งอ่านไบต์จากช่องถอดรหัส
* พวกเขาตาม
-
* @param แหล่งที่มา
* วัตถุ ReadableByteChannel ซึ่งจะถูกอ่านไปยัง EOF เป็น
* แหล่งที่มาของไบต์ที่เข้ารหัส
* @ผู้เขียน param
* วัตถุ Writer ที่จะเขียนตัวอักษรที่ถอดรหัส
* ชุดอักขระ @param
* วัตถุ Charset ซึ่ง CharsetDecoder จะใช้เพื่อทำ
* การถอดรหัสชุดอักขระ Java NIO 206
-
decodeChannel โมฆะคงที่สาธารณะ (แหล่ง ReadableByteChannel, นักเขียนนักเขียน,
ชุดอักขระชุดอักขระ) พ่น UnsupportedCharsetException, IOException {
// รับตัวอย่างตัวถอดรหัสจาก Charset
ตัวถอดรหัส CharsetDecoder = charset.newDecoder();
// บอกให้ถอดรหัสแทนที่ตัวอักษรที่เสียด้วยเครื่องหมายเริ่มต้น
decoder.onMalformedInput (CodingErrorAction.REPLACE);
decoder.onUnmappableCharacter (CodingErrorAction.REPLACE);
// จัดสรรขนาดบัฟเฟอร์อินพุตและเอาต์พุตที่แตกต่างกันอย่างสิ้นเชิง
// เพื่อวัตถุประสงค์ในการทดสอบ
ByteBuffer bb = ByteBuffer.allocateDirect(16 * 1024);
CharBuffer cb = CharBuffer.จัดสรร (57);
// บัฟเฟอร์เริ่มว่างเปล่า ระบุว่าจำเป็นต้องมีอินพุต
ผลลัพธ์ CoderResult = CoderResult.UNDERFLOW;
บูลีน eof = เท็จ;
ในขณะที่ (!eof) {
// บัฟเฟอร์อินพุตอันเดอร์โฟลว์; ตัวถอดรหัสต้องการอินพุตเพิ่มเติม
ถ้า (ผลลัพธ์ == CoderResult.UNDERFLOW) {
// ตัวถอดรหัสใช้อินพุตทั้งหมด เตรียมการเติม
bb.ชัดเจน();
// เติมบัฟเฟอร์อินพุต; ดู EOF
eof = (source.read(bb) == -1);
// เตรียมบัฟเฟอร์สำหรับการอ่านด้วยตัวถอดรหัส
bb.พลิก();
-
// ถอดรหัสไบต์อินพุตเป็นอักขระเอาต์พุต ผ่านแฟล็ก EOF
ผลลัพธ์ = decoder.decode (bb, cb, eof);
// หากบัฟเฟอร์เอาต์พุตเต็ม ให้ระบายเอาต์พุต
ถ้า (ผลลัพธ์ == CoderResult.OVERFLOW) {
sinkCharBuf (cb, นักเขียน);
-
-
// ล้างสถานะที่เหลืออยู่ออกจากตัวถอดรหัสด้วยความระมัดระวัง
// เพื่อตรวจจับบัฟเฟอร์ล้นเอาต์พุต
ในขณะที่ (decoder.flush(cb) == CoderResult.OVERFLOW) {
sinkCharBuf (cb, นักเขียน);
-
// ระบายตัวอักษรที่เหลืออยู่ในบัฟเฟอร์เอาต์พุต
sinkCharBuf (cb, นักเขียน);
// ปิดช่อง; ส่งข้อมูลบัฟเฟอร์ไปที่ stdout
แหล่งที่มา.ปิด();
นักเขียน.ฟลัช();
-

-
* วิธีการช่วยเหลือเพื่อระบายบัฟเฟอร์ถ่านและเขียนเนื้อหาไปยังที่กำหนด
* วัตถุตัวเขียนเมื่อส่งคืนบัฟเฟอร์จะว่างเปล่าและพร้อมที่จะเติม
-
* @param cb
* CharBuffer ที่มีตัวอักษรที่จะเขียน
* @ผู้เขียน param
* วัตถุ Writer เพื่อใช้ตัวอักษรในหน่วย cb
-
โมฆะคง DrainCharBuf (CharBuffer cb, นักเขียนนักเขียน) พ่น IOException {
cb.flip(); // เตรียมบัฟเฟอร์สำหรับการระบายน้ำ
// นี่เป็นการเขียนตัวอักษรที่มีอยู่ใน CharBuffer แต่
// ไม่ได้แก้ไขสถานะของบัฟเฟอร์จริงๆ
// หากบัฟเฟอร์ถ่านถูกระบายออกโดยการเรียกเพื่อรับ ( )
// อาจจำเป็นต้องมีการวนซ้ำที่นี่
ถ้า (cb.hasRemaining()) {
นักเขียน.write(cb.toString());
-
cb.clear(); // เตรียมบัฟเฟอร์เพื่อเติมอีกครั้ง
-
-

แพ็คเกจ com.ronsoft.books.nio.charset;

นำเข้า java.nio.CharBuffer;
นำเข้า java.nio.ByteBuffer;
นำเข้า java.nio.charset.Charset;
นำเข้า java.nio.charset.CharsetEncoder;
นำเข้า java.nio.charset.CharsetDecoder;
นำเข้า java.nio.charset.CoderResult;
นำเข้า java.util.Map;
นำเข้า java.util.Iterator;
นำเข้า java.io.Writer;
นำเข้า java.io.PrintStream;
นำเข้า java.io.PrintWriter;
นำเข้า java.io.OutputStreamWriter;
นำเข้า java.io.BufferedReader;
นำเข้า java.io.InputStreamReader;
นำเข้า java.io.FileReader;

-
* การใช้งาน Charset ซึ่งทำการเข้ารหัส Rot13 คือ
* อัลกอริธึมการทำให้ข้อความสับสนอย่างง่ายซึ่งเปลี่ยนอักขระตามตัวอักษร 13
* เพื่อให้ 'a' กลายเป็น 'n', 'o' กลายเป็น 'b' เป็นต้น อัลกอริธึมนี้ได้รับความนิยม
* โดยฟอรัม Usenet เมื่อหลายปีก่อนเพื่อปกปิดคำพูดซุกซนซ่อน
* คำตอบสำหรับคำถามและอื่น ๆ อัลกอริธึม Rot13 เป็นแบบสมมาตรและนำไปใช้
* เป็นข้อความที่ถูกรบกวนโดย Rot13 จะให้ต้นฉบับแก่คุณ
* ข้อความที่ไม่มีสัญญาณรบกวน
-
* การใช้การเข้ารหัส Charset นี้กับสตรีมเอาท์พุตจะทำให้ทุกอย่างเกิดขึ้นกับคุณ
* เขียนไปที่สตรีมนั้นเพื่อให้ Rot13 กวนตามที่เขียนออกมาและใช้งาน
* ไปยังสตรีมอินพุตทำให้ข้อมูลที่อ่านถูกถอดรหัส Rot13 ขณะที่อ่าน
-
* @ผู้เขียนรอน ฮิตเชนส์ ([email protected])
-
คลาสสาธารณะ Rot13Charset ขยาย Charset {
// ชื่อของการเข้ารหัสชุดอักขระฐานที่เรามอบหมายให้
สตริงสุดท้ายแบบคงที่ส่วนตัว BASE_CHARSET_NAME = "UTF-8";
// จัดการกับชุดอักขระจริงที่เราจะใช้สำหรับการแปลงรหัสระหว่าง
// อักขระและไบต์ การทำเช่นนี้ช่วยให้เราสามารถใช้ Rot13 ได้
// อัลกอริธึมสำหรับการเข้ารหัสชุดอักขระแบบหลายไบต์
// ตัวอักษรอัลฟ่า ASCII จะถูกหมุน โดยไม่คำนึงถึงการเข้ารหัสพื้นฐาน
ชุดอักขระฐานชุดอักขระ;

-
* ตัวสร้างสำหรับชุดอักขระ Rot13 เรียกตัวสร้างซูเปอร์คลาสไปที่
* ส่งต่อชื่อที่เราจะรู้จักด้วย จากนั้นให้บันทึกการอ้างอิงไปที่
* มอบหมาย Charset
-
ป้องกัน Rot13Charset (สตริงที่เป็นที่ยอมรับ, นามแฝงสตริง []) {
ซุปเปอร์ (บัญญัติ นามแฝง);
// บันทึกชุดอักขระฐานที่เรากำลังมอบหมายให้
baseCharset = Charset.forName(BASE_CHARSET_NAME);
-

//------------------------------------------------ ----------
-
* เรียกโดยผู้ใช้ Charset นี้เพื่อรับตัวเข้ารหัส
* สร้างอินสแตนซ์ของคลาสส่วนตัว (กำหนดไว้ด้านล่าง) แล้วส่งต่อ
* ตัวเข้ารหัสจาก Charset ฐาน
-
CharsetEncoder สาธารณะ newEncoder () {
ส่งคืน Rot13Encoder ใหม่ (นี่คือ baseCharset.newEncoder ());
-

-
* เรียกโดยผู้ใช้ Charset นี้เพื่อรับตัวถอดรหัส
* สร้างอินสแตนซ์ของคลาสส่วนตัว (กำหนดไว้ด้านล่าง) แล้วส่งต่อ
* ตัวถอดรหัสจาก Charset ฐาน
-
CharsetDecoder สาธารณะ newDecoder () {
ส่งคืน Rot13Decoder ใหม่ (นี่, baseCharset.newDecoder ());
-

-
* วิธีการนี้จะต้องดำเนินการโดย Charsets ที่เป็นรูปธรรม เรามักจะบอกว่าไม่
*ซึ่งมีความปลอดภัย
-
บูลีนสาธารณะประกอบด้วย (ชุดอักขระ cs) {
กลับ (เท็จ);
-

-
* กิจวัตรทั่วไปเพื่อหมุนตัวอักษรอัลฟ่า ASCII ทั้งหมดในที่กำหนด
* CharBuffer คูณ 13 โปรดทราบว่าโค้ดนี้เปรียบเทียบค่า upper และ
* ตัวอักษร ASCII ตัวพิมพ์เล็กแทนที่จะใช้วิธีการ
* Character.isLowerCase และ Character.isUpperCase นี่เป็นเพราะว่า
* รูปแบบการหมุนเวียนด้วย 13 ใช้ได้กับอักขระตัวอักษรของเท่านั้น
* ชุดอักขระ ASCII และวิธีการเหล่านั้นสามารถคืนค่าเป็นจริงสำหรับ Unicode ที่ไม่ใช่ ASCII
* ตัวอักษร
-
โมฆะส่วนตัว rot13 (CharBuffer cb) {
สำหรับ (int pos = cb.position(); pos < cb.limit(); pos++) {
ถ่าน c = cb.get(pos);
ถ่าน = '/u0000';
// มันเป็นอัลฟ่าตัวพิมพ์เล็กเหรอ?
ถ้า ((c >= 'a') && (c <= 'z')) {
ก = 'ก';
-
// มันเป็นอัลฟ่าตัวพิมพ์ใหญ่เหรอ?
ถ้า ((c >= 'A') && (c <= 'Z')) {
ก = 'ก';
-
// ถ้าอย่างใดอย่างหนึ่ง ให้ทอยมันด้วย 13
ถ้า (เป็น != '/u0000') {
c = (ถ่าน) ((((c - a) + 13) % 26) + a);
cb.put(pos, c);
-
-
-

//------------------------------------------------ --------
-
* การใช้ตัวเข้ารหัสสำหรับ Rot13 Chars et คลาสนี้และ
* คลาสตัวถอดรหัสที่ตรงกันด้านล่าง ควรแทนที่เมธอด "impl" ด้วย
* เช่น implOnMalformedInput( ) และทำการเรียก passthrough ไปที่
* วัตถุ baseEncoder ที่เหลือเป็นแบบฝึกหัดสำหรับแฮ็กเกอร์
-
คลาสส่วนตัว Rot13Encoder ขยาย CharsetEncoder {
CharsetEncoder ส่วนตัว baseEncoder;

-
* Constructor เรียก Constructor ซูเปอร์คลาสด้วยวัตถุ Charset
* และขนาดการเข้ารหัสจากตัวเข้ารหัสของผู้ร่วมประชุม
-
Rot13Encoder (ชุดอักขระ cs, ตัวเข้ารหัสฐาน CharsetEncoder) {
ซุปเปอร์ (cs, baseEncoder.averageBytesPerChar(), baseEncoder
.maxBytesPerChar());
this.baseEncoder = baseEncoder;
-

-
* การใช้งานลูปการเข้ารหัส ขั้นแรกเราใช้ Rot13
* อัลกอริธึมการแย่งชิงไปยัง CharBuffer จากนั้นรีเซ็ตตัวเข้ารหัสสำหรับ
* Charset ฐานและเรียกมันว่า encode( ) วิธีการทำจริง
* การเข้ารหัส อาจทำงานไม่ถูกต้องสำหรับชุดอักขระที่ไม่ใช่ภาษาละติน
* CharBuffer ที่ส่งผ่านอาจอ่านได้อย่างเดียวหรือนำกลับมาใช้ใหม่โดยผู้โทร
* วัตถุประสงค์อื่น ๆ ดังนั้นเราจึงทำซ้ำและใช้การเข้ารหัส Rot13 กับ
* คัดลอก เราต้องการเลื่อนตำแหน่งของบัฟเฟอร์อินพุตไปที่
* สะท้อนถึงตัวอักษรที่ใช้ไป
-
ป้องกัน CoderResult encodeLoop (CharBuffer cb, ByteBuffer bb) {
CharBuffer tmpcb = CharBuffer.allocate(cb.remaining());
ในขณะที่ (cb.hasRemaining()) {
tmpcb.put(cb.get());
-
tmpcb.ย้อนกลับ();
rot13(tmpcb);
baseEncoder.รีเซ็ต();
CoderResult cr = baseEncoder.encode(tmpcb, bb, จริง);
// หากเกิดข้อผิดพลาดหรือเอาต์พุตล้น เราจำเป็นต้องปรับเปลี่ยน
// ตำแหน่งของบัฟเฟอร์อินพุตให้ตรงกับตำแหน่งใด
// ถูกใช้ไปจริงๆ จากบัฟเฟอร์ชั่วคราว
// อันเดอร์โฟลว์ (อินพุตทั้งหมดถูกใช้ไป) นี่คือ no-op
cb.position(cb.position() - tmpcb.remaining());
กลับ(cr);
-
-

//------------------------------------------------ --------
-
* การใช้งานตัวถอดรหัสสำหรับ Rot13 Charset
-
คลาสส่วนตัว Rot13Decoder ขยาย CharsetDecoder {
CharsetDecoder ส่วนตัว baseDecoder;

-
* Constructor เรียก Constructor ซูเปอร์คลาสด้วยวัตถุ Charset
* และส่งผ่านค่าตัวอักษร/ไบต์จากตัวถอดรหัสของผู้รับมอบสิทธิ์
-
Rot13Decoder (ชุดอักขระ cs, CharsetDecoder baseDecoder) {
ซุปเปอร์ (cs, baseDecoder.averageCharsPerByte(), baseDecoder
.maxCharsPerByte());
this.baseDecoder = ฐานถอดรหัส;
-

-
* การใช้งานลูปการถอดรหัส ขั้นแรกเรารีเซ็ตตัวถอดรหัสสำหรับ
* ชุดอักขระฐานแล้วเรียกเพื่อถอดรหัสไบต์เป็นอักขระ
* บันทึกโค้ดผลลัพธ์ จากนั้น CharBuffer จะถูกถอดรหัสสัญญาณด้วย
* อัลกอริทึม Rot13 และรหัสผลลัพธ์จะถูกส่งกลับ สิ่งนี้อาจไม่ทำงาน
* ถูกต้องสำหรับชุดอักขระที่ไม่ใช่ภาษาละติน
-
ป้องกัน CoderResult decodeLoop (ByteBuffer bb, CharBuffer cb) {
baseDecoder.รีเซ็ต();
CoderResult result = AffraseCoder.decode (BB, CB, TRUE);
ROT13 (CB);
return (ผลลัพธ์);
-
-

// ---------------------------------------------------------------------------------------------------------------------------------------------------- --------
-
* การทดสอบหน่วยสำหรับ ROT13 Charset
* ไฟล์หากมีชื่ออยู่บนบรรทัดคำสั่งหรือ stdin หากไม่มีการจัดเตรียม args และ
* เขียนเนื้อหาไปยัง stdout ผ่านการเข้ารหัส X -Rot13 Charset
* "การเข้ารหัส" ที่ใช้โดยอัลกอริทึม ROT13 นั้นสมมาตร
* ในไฟล์ข้อความธรรมดาเช่นซอร์สโค้ด Java จะส่งออก
* เวอร์ชัน Scrambled
* เอกสารข้อความธรรมดาต้นฉบับ
-
โมฆะคงที่สาธารณะหลัก (สตริง [] argv) โยนข้อยกเว้น {
bufferedreader in;
if (argv. length> 0) {
// เปิดไฟล์ชื่อ
ใน = ใหม่ bufferedReader (filereader ใหม่ (argv [0]));
} อื่น {
// ห่อบัฟเฟอร์รีดรอบ stdin
ใน = ใหม่ bufferedReader (ใหม่ inputStreamReader (system.in));
-
// สร้าง printstream ที่ใช้การเข้ารหัส ROT13
printstream out = new printstream (system.out, false, "x -rot13");
สตริง s = null;
// อ่านอินพุตทั้งหมดและเขียนลงในเอาต์พุต
// เมื่อข้อมูลผ่าน PrintStream
// มันจะถูกเข้ารหัส ROT13
ในขณะที่ ((s = in.readline ())! = null) {
out.println (s);
-
ออก.ล้าง();
-
-

แพ็คเกจ com.ronsoft.books.nio.charset;

นำเข้า java.nio.charset.charset;
นำเข้า java.nio.charset.spi.charsetprovider;
นำเข้า java.util.HashSet;
นำเข้า java.util.iterator;

-
* คลาส charsetprovider ซึ่งทำให้มีชุด charsets ที่จัดทำโดย
* Ronsoft
* ไม่ใช่ชุด charset ของ Iana ที่ลงทะเบียนดังนั้นชื่อจึงขึ้นอยู่กับ "X-" เพื่อหลีกเลี่ยงชื่อ
* ปะทะกับ Charsets เป็นทางการ
-
* ในการเปิดใช้งาน CharsetProvider นี้จำเป็นต้องเพิ่มไฟล์ลงในไฟล์
* ClassPath ของ JVM Runtime ที่ตำแหน่งต่อไปนี้:
* meta-inf/services/java.nio.charsets.spi.charsetprovider
-
* ไฟล์นั้นจะต้องมีบรรทัดที่มีชื่อที่ผ่านการรับรองของคลาสนี้บน
* บรรทัดด้วยตัวเอง: com.ronsoft.books.nio.charset.ronsoftcharsetprovider java
* Nio 216
-
* ดูหน้า javadoc สำหรับ java.nio.charsets.spi.charsetprovider สำหรับเต็ม
* รายละเอียด.
-
* @author Ron Hitchens ([email protected])
-
คลาสสาธารณะ RonsoftCharsetProvider ขยาย CharsetProvider {
// ชื่อของชุดที่เราให้
สตริงสุดท้ายคงที่ส่วนตัว charset_name = "X-ROT13";
// ที่จับไปยังวัตถุ Charset
charset ส่วนตัว rot13 = null;

-
* ตัวสร้างสร้างอินสแตนซ์วัตถุ Charset และบันทึกการอ้างอิง
-
สาธารณะ RonsoftCharSetProvider () {
this.rot13 = ใหม่ rot13charset (charset_name, สตริงใหม่ [0]);
-

-
* เรียกโดยวิธีการ charset static เพื่อค้นหา charset ที่มีชื่อเฉพาะ
* มันเป็นชื่อของชุดนี้ (เราไม่มีนามแฝงใด ๆ ) จากนั้นส่งคืนไฟล์
* rot13 charset, elfle return null
-
charset charsetforName สาธารณะ (สตริง charsetName) {
if (charsetName.equalsignorecase (charset_name)) {
return (rot13);
-
return (null);
-

-
* ส่งคืนตัววนซ้ำผ่านชุดของวัตถุ charset ที่เรามีให้
-
* @return วัตถุตัววนซ้ำที่มีการอ้างอิงถึง charset ทั้งหมด
* วัตถุที่จัดทำโดยคลาสนี้
-
Public Iterator <Charset> Charsets () {
HashSet <Charset> set = new HashSet <Charset> (1);
set.add (rot13);
return (set.iterator ());
-
-

การเพิ่ม x -rot13 ลงในรายการชุดอักขระในตัวอย่าง 6-1 สร้างผลลัพธ์เพิ่มเติมนี้:

Charset: X-ROT13
อินพุต: żmaana?
เข้ารหัส:
0: C2 (ż)
1: BF (ż)
2: 5a (Z)
3: 6e (n)
4: C3 (ă)
5: B1 (±)
6: 6e (n)
7:61 (ก)
8: 6e (n)
9: 3F (?)