Javaの文字エンコードとデコードの実装の詳細な説明

パッケージ com.ronsoft.books.nio.charset;

インポート java.nio.charset.Charset;
インポートjava.nio.ByteBuffer;

/**
* いくつかの文字列を含む同じ入力文字列を実行します。
* 非 ASCII 文字は、いくつかの Charset エンコーダを介して 16 進数をダンプします
* 結果として得られるバイト シーケンスの値。
*
* @著者 Ron Hitchens ([email protected])
*/
パブリック クラス EncodeTest {
public static void main(String[] argv) throws Exception {
// これはエンコードする文字列です
文字列入力 = "/u00bfMa/u00f1ana?";
// エンコードに使用する文字セットのリスト
String[] charsetNames = { "US-ASCII"、"ISO-8859-1"、"UTF-8"、
"UTF-16BE"、"UTF-16LE"、"UTF-16" // 、"X-ROT13"
};
for (int i = 0; i < charsetNames.length; i++) {
doEncode(Charset.forName(charsetNames[i]), input);
}
}

/**
* 指定された文字セットと入力文字列について、文字をエンコードして出力します。
* 読み取り可能な形式でバイトエンコードが行われます。
*/
private static void doEncode(Charset cs, String input) {
ByteBuffer bb = cs.encode(input);
System.out.println("文字セット: " + cs.name());
System.out.println(" 入力: " + 入力);
System.out.println("エンコード: ");
for (int i = 0; bb.hasRemaining(); i++) {
int b = bb.get();
int ival = ((int) b) & 0xff;
char c = (char) ival;
// 表の配置をきれいに保つ
if (i < 10)
System.out.print(" ");
//インデックス番号を出力する
System.out.print(" " + i + ": ");
// より良いフォーマットの出力がいつか来るでしょう...
if (ival < 16)
System.out.print("0");
// バイトの 16 進値を出力します
System.out.print(Integer.toHexString(ival));
// バイトが a の値であると思われる場合
// 印刷可能な文字、印刷する保証はありません。
// そうなる。
if (Character.isWhitespace(c) || Character.isISOControl(c)) {
System.out.println("");
} それ以外 {
System.out.println(" (" + c + ")");
}
}
System.out.println("");
}
}

文字セット: ISO-8859-1
入力:「マ?アナ?」
エンコード済み:
0:20
1: BF(?)
2:4d(M)
3:61(a)
4:f1(?)
5:61(a)
6:6e(n)
7:61(a)
8：3f(?)

文字セット: UTF-8
入力:「マ?アナ?」
エンコード済み:
0:20
1:c2(?)
2: BF(?)
3:4d(M)
4:61(a)
5：c3(?)
6: b1(±)
7:61(a)
8:6e(n)
9:61(a)
10：3f(?)

文字セット: UTF-16BE
入力:「マ?アナ?」
エンコード済み:
0:00
1:20
2:00
3: BF(?)
4:00
5：4d(M)
6:00
7:61(a)
8:00
9:f1(?)
10:00
11:61(a)
12:00
13:6e(n)
14:00
15:61(a)
16:00
17：3f(?)

文字セット: UTF-16LE
入力:「マ?アナ?」
エンコード済み:
0:20
1:00
2: BF(?)
3:00
4:4d(M)
5:00
6:61(a)
7:00
8:f1(?)
9:00
10:61(a)
11:00
12:6e(n)
13:00
14:61(a)
15:00
16：3f(?)
17:00

文字セット: UTF-16
入力:「マ?アナ?」
エンコード済み:
0:フェ(?)
1: ふ(?)
2:00
3:20
4:00
5：BF(?)
6:00
7：4d(M)
8:00
9:61(a)
10:00
11：f1(?)
12:00
13:61(a)
14:00
15:6e(n)
16:00
17:61(a)
18:00
19：3f(?)

パッケージ java.nio.charset;
パブリック抽象クラス Charset は Comparable を実装します
{
public static boolean isSupported (String charsetName)
public static Charset forName (String charsetName)
public static SortedMap availableCharsets()
パブリック最終文字列名()
public Final Set aliases()
public String 表示名()
public String displayName (ロケール locale)
パブリック最終ブール値 isRegistered()
パブリックブール値 canEncode()
パブリック抽象CharsetEncoder newEncoder();
パブリック最終 ByteBuffer エンコード (CharBuffer cb)
パブリック最終 ByteBuffer エンコード (文字列 str)
パブリック抽象CharsetDecoder newDecoder();
パブリック最終 CharBuffer デコード (ByteBuffer bb)
public abstract boolean には (Charset cs) が含まれます。
public 最終ブール値等しい (オブジェクト ob)
public Final int CompareTo (オブジェクト ob)
public Final int hashCode()
パブリック最終文字列 toString()
}

パブリック抽象クラス Charset は Comparable を実装します
{
// これは API リストの一部です
public abstract boolean には (Charset cs) が含まれます。
public 最終ブール値等しい (オブジェクト ob)
public Final int CompareTo (オブジェクト ob)
public Final int hashCode()
パブリック最終文字列 toString()
}

パッケージ java.nio.charset;
パブリック抽象クラス CharsetEncoder
{
// これは API リストの一部です
public boolean canEncode (char c)
public boolean canEncode (CharSequence cs)
}

パッケージ java.nio.charset;
パブリック クラス CoderResult {
public static Final CoderResult オーバーフロー
public static Final CoderResult UNDERFLOW
パブリックブール値 isUnderflow()
パブリックブール値 isOverflow()
<span style="white-space:pre"> </span>public boolean isError()
public boolean isMalformed()
パブリックブール値 isUnmappable()
パブリック int length()
public static CoderResult malformedForLength (int 長)
public static CoderResult unmappableForLength (int 長)
<span style="white-space:pre"> </span>public void throwException() は CharacterCodingException をスローします
}

パッケージ java.nio.charset;
パブリック抽象クラス CharsetDecoder
{
// これは API リストの一部です
public Final CharsetDecoder リセット()
パブリック最終 CharBuffer デコード (ByteBuffer in)
CharacterCodingException をスローします
public 最終 CoderResult デコード (ByteBuffer 入力、CharBuffer 出力、
ブール値の入力の終了)
パブリック最終 CoderResult フラッシュ (CharBuffer 出力)
}

パッケージ com.ronsoft.books.nio.charset;

java.nio.* をインポートします。
java.nio.charset.* をインポートします。
java.nio.channels.* をインポートします。
java.io.* をインポートします。

/**
* 文字セットのデコードをテストします。
*
* @著者 Ron Hitchens ([email protected])
*/
パブリック クラス CharsetDecode {
/**
* 一般的なケースでの文字セットのデコードをテストし、バッファを検出して処理します
* アンダー/オーバーフロー、および入力終了時のデコーダー状態のフラッシュ。
* stdin から読み取り、ASCII エンコードされたバイト ストリームを文字にデコードします。
* デコードされた文字は stdout に書き込まれます。これは事実上 'cat' です。
* ASCII ファイルを入力しますが、単純に別の文字セット エンコーディングを使用することもできます。
* コマンドラインで指定します。
*/
public static void main(String[] argv) throws IOException {
// デフォルトの文字セットは標準 ASCII です
文字列文字セット名 = "ISO-8859-1";
// 文字セット名はコマンドラインで指定可能
if (引数の長さ > 0) {
charsetName = argv[0];
}
// チャネルを標準入力にラップし、チャネルを標準出力にラップし、
// 指定された Charset を検索し、それらを deco de メソッドに渡します。
// 指定された文字セットが無効な場合、次のタイプの例外が発生します。
// UnsupportedCharsetException がスローされます。
decodeChannel(Channels.newChannel(System.in), new OutputStreamWriter(
System.out)、Charset.forName(charsetName));
}

/**
* チャネルからバイトを読み取り、デコードする汎用静的メソッド
*彼らによると
*
* @paramソース
* EOF に読み取られる ReadableByteChannel オブジェクト
* エンコードされたバイトのソース。
* @paramライター
* デコードされた文字が書き込まれる Writer オブジェクト。
* @param 文字セット
* Charset オブジェクト。その CharsetDecoder は次の処理を行うために使用されます。
* 文字セットのデコード。Java NIO 206。
*/
public static void decodeChannel(ReadableByteChannel ソース、ライター ライター、
Charset charset) throws UnsupportedCharsetException、IOException {
// Charset からデコーダ インスタンスを取得します
CharsetDecoder デコーダ = charset.newDecoder();
// 不正な文字をデフォルトのマークに置き換えるようデコーダに指示します
decoder.onMalformedInput(CodingErrorAction.REPLACE);
decoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
// 根本的に異なる入力バッファ サイズと出力バッファ サイズを割り当てます。
// テスト目的のため
ByteBuffer bb = ByteBuffer.allocateDirect(16 * 1024);
CharBuffer cb = CharBuffer.allocate(57);
// バッファは空から始まり、入力が必要であることを示します。
CoderResult 結果 = CoderResult.UNDERFLOW;
ブール値 eof = false;
while (!eof) {
// 入力バッファーのアンダーフローがさらに多くの入力を必要とします。
if (結果 == CoderResult.UNDERFLOW) {
// デコーダはすべての入力を消費し、補充の準備をします
bb.clear();
// 入力バッファを埋めて EOF を監視します。
eof = (source.read(bb) == -1);
// デコーダによる読み取り用のバッファを準備します
bb.flip();
}
// 入力バイトをデコードして文字を出力し、EOF フラグを渡します。
結果 = デコーダ.デコード(bb, cb, eof);
// 出力バッファがいっぱいの場合、出力を排出します
if (result == CoderResult.OVERFLOW) {
ドレインCharBuf(cb、ライター);
}
}
// 注意して、残っている状態をデコーダからフラッシュします。
// 出力バッファのオーバーフローを検出するため
while (decoder.flush(cb) == CoderResult.OVERFLOW) {
ドレインCharBuf(cb、ライター);
}
// 出力バッファに残っている文字をすべて排出します
ドレインCharBuf(cb、ライター);
// チャネルを閉じて、バッファされたデータを標準出力にプッシュします。
ソース.close();
ライター.flush();
}

/**
* 文字バッファを排出し、その内容を指定されたバッファに書き込むヘルパー メソッド
* Writer オブジェクト。戻ると、バッファは空になり、再充填する準備ができています。
*
* @param cb
* 書き込まれる文字を含む CharBuffer。
* @paramライター
* cb 内の文字を消費するための Writer オブジェクト。
*/
static voidrainCharBuf(CharBuffer cb, Writer Writer) throws IOException {
cb.flip(); // ドレイン用のバッファを準備します
// これは CharBuffer に含まれる文字を書き込みますが、
// 実際にはバッファの状態を変更しません。
// get( ) の呼び出しによって char バッファが空になっていた場合、
// ここでループが必要になる場合があります。
if (cb.hasRemaining()) {
Writer.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をインポートします。

/**
* Rot13 エンコーディングを実行する Charset 実装は、Rot-13 エンコーディングです。
* アルファベット文字を 13 ずつシフトする単純なテキスト難読化アルゴリズム
* 'a' が 'n' になる、'o' が 'b' になるなど。このアルゴリズムは普及しました
* 何年も前に Usenet ディスカッション フォーラムによって、いたずらな言葉を隠し、非表示にするために
* 質問への回答など。Rot13 アルゴリズムは対称的です。
* Rot13 によってスクランブルされたテキストにすると、オリジナルが得られます
*スクランブルされていないテキスト。
*
* この Charset エンコーディングを出力ストリームに適用すると、
* 書き出されたときに Rot13 でスクランブルされるようにそのストリームに書き込み、適用します。
* 入力ストリームに追加すると、読み取られたデータは読み取られる際に Rot13 デスクランブルされます。
*
* @著者 Ron Hitchens ([email protected])
*/
public class Rot13Charset extends Charset {
// 委任する基本文字セットエンコーディングの名前
プライベート静的最終文字列BASE_CHARSET_NAME = "UTF-8";
// 間のトランスコーディングに使用する実際の文字セットへのハンドル
// 文字とバイト これにより、Rot13 を適用できるようになります。
// マルチバイト文字セットエンコーディングへのアルゴリズム。
// ASCII アルファ文字は、基本エンコーディングに関係なく回転されます。
文字セットbaseCharset;

/**
* Rot13 文字セットのコンストラクター スーパークラス コンストラクターを呼び出します。
* 私たちが知られる名前を渡してから、への参照を保存します。
* デリゲートの文字セット。
*/
protected Rot13Charset(String canonical, String[] エイリアス) {
super(正規、エイリアス);
// 委任先の基本文字セットを保存します
BaseCharset = Charset.forName(BASE_CHARSET_NAME);
}

//------------------------------------------------ ----------
/**
* この実装を取得するために、この文字セットのユーザーによって呼び出されます。
* プライベート クラス (以下で定義) のインスタンスをインスタンス化し、それを渡します
* 基本文字セットからのエンコーダー。
*/
public CharsetEncoder newEncoder() {
return new Rot13Encoder(this,baseCharset.newEncoder());
}

/**
* この実装を取得するために、この文字セットのユーザーによって呼び出されます。
* プライベート クラス (以下で定義) のインスタンスをインスタンス化し、それを渡します
* 基本文字セットからのデコーダ。
*/
public CharsetDecoder newDecoder() {
return new Rot13Decoder(this,baseCharset.newDecoder());
}

/**
* このメソッドは具体的な文字セットで実装する必要があります。私たちは常に「ノー」と言います。
*安全です。
*/
public boolean contains(Charset cs) {
戻り値 (偽);
}

/**
* 指定されたファイル内のすべての ASCII アルファ文字を回転する共通ルーチン
* CharBuffer by 13。このコードは、upper と を明示的に比較していることに注意してください。
* メソッドを使用するのではなく、小文字の ASCII 文字を使用します
* Character.isLowerCase と Character.isUpperCase であるためです。
* 13 単位で回転するスキームは、次のアルファベット文字に対してのみ適切に機能します。
* ASCII 文字セットとそれらのメソッドは、非 ASCII Unicode に対して true を返すことができます
* 文字。
*/
プライベート void rot13(CharBuffer cb) {
for (int pos = cb.position(); pos < cb.limit(); pos++) {
char c = cb.get(pos);
文字 a = '/u0000';
// 小文字のアルファベットですか?
if ((c >= 'a') && (c <= 'z')) {
a = 'a';
}
// アルファベット大文字ですか?
if ((c >= 'A') && (c <= 'Z')) {
a = 'A';
}
// どちらかの場合は 13 ロールします
if (a != '/u0000') {
c = (char) ((((c - a) + 13) % 26) + a);
cb.put(pos, c);
}
}
}

//------------------------------------------------ --------
/**
* Rot13 Chars et のエンコーダ実装、および
* 以下の一致するデコーダー クラスは、「impl」メソッドもオーバーライドする必要があります。
* implOnMalformedInput( ) など、
*baseEncoder オブジェクト。これはハッカーの演習として残されています。
*/
プライベート クラス Rot13Encoder は CharsetEncoder を拡張します {
プライベート CharsetEncoder BaseEncoder;

/**
* コンストラクター。Charset オブジェクトを使用してスーパークラス コンストラクターを呼び出します。
* およびデリゲート エンコーダーからのエンコーディング サイズ。
*/
Rot13Encoder(Charset cs, CharsetEncoderbaseEncoder) {
super(cs,baseEncoder.averageBytesPerChar(),baseEncoder
.maxBytesPerChar());
this.baseEncoder = BaseEncoder;
}

/**
* エンコードループの実装 まず、Rot13 を適用します。
* CharBuffer にアルゴリズムをスクランブルし、エンコーダーをリセットします。
* 基本文字セットを指定し、実際の処理を行うためにその encode() メソッドを呼び出します。
* エンコーディングは、ラテン語以外の文字セットでは正しく動作しない可能性があります。
* 渡された CharBuffer は読み取り専用であるか、呼び出し元によって再利用される場合があります。
* 他の目的があるため、これを複製し、Rot13 エンコーディングを適用します。
* 入力バッファの位置を次へ進めたいと考えています。
* 消費された文字数を反映します。
*/
protected CoderResult encodeLoop(CharBuffer cb, ByteBuffer bb) {
CharBuffer tmpcb = CharBuffer.allocate(cb.remaining());
while (cb.hasRemaining()) {
tmpcb.put(cb.get());
}
tmpcb.rewind();
rot13(tmpcb);
BaseEncoder.reset();
CoderResult cr = BaseEncoder.encode(tmpcb, bb, true);
// エラーまたは出力オーバーフローの場合は、調整する必要があります
// 一致する入力バッファの位置
// 実際に一時バッファから消費された場合。
// アンダーフロー (すべての入力が消費される)、これは何も行われません。
cb.position(cb.position() - tmpcb.remaining());
リターン(cr);
}
}

//------------------------------------------------ --------
/**
* Rot13 Charset のデコーダー実装。
*/
プライベート クラス Rot13Decoder は CharsetDecoder を拡張します {
プライベート CharsetDecoder ベースデコーダ;

/**
* コンストラクター。Charset オブジェクトを使用してスーパークラス コンストラクターを呼び出します。
* デリゲート デコーダーから文字/バイト値を渡します。
*/
Rot13Decoder(Charset cs, CharsetDecoderbaseDecoder) {
super(cs,baseDecoder.averageCharsPerByte(),baseDecoder
.maxCharsPerByte());
this.baseDecoder = BaseDecoder;
}

/**
* デコードループの実装 まず、デコーダをリセットします。
* 基本文字セット。それを呼び出してバイトを文字にデコードします。
* 結果コードを保存すると、CharBuffer がスクランブル解除されます。
* Rot13 アルゴリズムと結果コードが返される場合、これは機能しない可能性があります。
* 非ラテン語の文字セットに対して適切に。
*/
protected CoderResult decodeLoop(ByteBuffer bb, CharBuffer cb) {
BaseDecoder.reset();
coderresult result = badedecoder.decode（bb、cb、true）;
ROT13（CB）;
return（result）;
}
}

// ----------------------------------------------------------- --------
/**
* rot13 charsetの単位テスト
*コマンドラインに名前が付けられている場合、またはargsが提供されていない場合はstdin、および
* X -ROT13 CHARSETエンコードを介して内容をSTDOUTに書き込みます
* ROT13アルゴリズムによって実装される「暗号化」は対称です
*たとえば、Javaソースコードなどのプレーンテキストファイルでは、
*スクランブルバージョンに戻ってきます
*オリジナルのプレーンテキストドキュメント。
*/
public static void main（string [] argv）スロー例外{
bufferedReader;
if（argv。length> 0）{
//名前付きファイルを開きます
in = new BufferedReader（new fileReader（argv [0]））;
} それ以外 {
// stdinの周りにバッファレッドリーダーをラップします
in = new BufferedReader（new inputStreamReader（System.in））;
}
// rot13エンコーディングを使用するprintStreamを作成します
printStream out = new PrintStream（system.out、false、 "x -rot13"）;
文字列 s = null;
//すべての入力を読み取り、出力に書き込みます。
//データがprintStreamを通過すると、
// rot13エンコードされます。
while（（s = in.readline（））！= null）{
out.println（s）;
}
out.flush();
}
}

パッケージcom.ronsoft.books.nio.charset;

java.nio.charset.charsetをインポートします。
java.nio.charset.spi.charsetproviderをインポートします。
java.util.HashSet をインポートします。
java.util.iteratorをインポートします。

/**
*提供された充電器を利用可能にするcharsetproviderクラス
* Ronsoft
*登録されたiana charsetではないので、名前は「x-」で始まり、名前を避けるために始まります
*オフカルの充電と衝突します。
*
*このcharsetproviderをアクティブにするには、ファイルをに追加する必要があります
*次の場所でのJVMランタイムのクラスパス：
* Meta-inf/services/java.nio.charsets.spi.charsetprovider
*
*そのファイルには、このクラスの完全な資格のある名前のラインが含まれている必要があります
*単独で行：com.ronsoft.books.nio.Charset.RonsoftCharsetProvider Java
* NIO 216
*
* java.nio.charsets.spi.charsetproviderのJavadocページを参照してください
* 詳細。
*
* @author ron hitchens（[email protected]）
*/
Public Class RonsoftCharsetProviderはCharSetProviderを拡張します{
//提供するcharsetの名前
プライベート静的最終文字列charset_name = "x-rot13";
// charsetオブジェクトのハンドル
プライベートチャーセットrot13 = null;

/**
*コンストラクター、チャーセットオブジェクトをインスタンス化し、参照を保存します。
*/
public ronsoftcharsetprovider（）{
this.rot13 = new Rot13Charset（charset_name、new String [0]）;
}

/**
* Charset staticメソッドによって呼び出され、特定の名前のcharset
*これはこのチャーセットの名前です（エイリアスはありません）。
* rot13 charset、それはnullを返します。
*/
パブリックチャーセットcharsetforname（string charsetname）{
if（charsetname.equalsignorecase（charset_name））{
return（rot13）;
}
return（null）;
}

/**
*私たちが提供するチャーセットオブジェクトのセットに反復器を返します。
*
* @returnすべてのcharsetへの参照を含むイテレーターオブジェクト
*このクラスが提供するオブジェクト。
*/
public Iterator <Charset> charsets（）{
Hashset <Charset> set = new Hashset <Charset>（1）;
set.add（rot13）;
return（set.iterator（））;
}
}

例6-1の文字セットリストにx -rot13を追加すると、この追加の出力が生成されます。

charset：x-rot13
入力：chmaana？
エンコード：
0：c2（o）
1：BF（Q）
2：5a（z）
3：6e（n）
4：C3（¡）
5：B1（±）
6：6e（n）
7:61（a）
8：6e（n）
9：3f（？）