Explicación detallada de la implementación de la codificación y decodificación de caracteres Java.

paquete com.ronsoft.books.nio.charset;

importar java.nio.charset.Charset;
importar java.nio.ByteBuffer;

/**
* Prueba de codificación de caracteres. Ejecute la misma cadena de entrada, que contiene algo.
* caracteres no ASCII, a través de varios codificadores Charset y descartar el hexadecimal
* valores de las secuencias de bytes resultantes.
*
* @autor Ron Hitchens ([email protected])
*/
clase pública EncodeTest {
public static void main (String [] argv) lanza una excepción {
// Esta es la secuencia de caracteres a codificar
Entrada de cadena = "/u00bfMa/u00f1ana?";
// la lista de conjuntos de caracteres para codificar
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]), entrada);
}
}

/**
* Para un conjunto de caracteres y una cadena de entrada determinados, codifique los caracteres e imprima el
* codificación de bytes resultante en un formato legible.
*/
doEncode vacío estático privado (Charset cs, entrada de cadena) {
ByteBuffer bb = cs.encode(entrada);
System.out.println("Juego de caracteres: " + cs.name());
System.out.println(" Entrada: " + entrada);
System.out.println("Codificado: ");
para (int i = 0; bb.hasRemaining(); i++) {
int b = bb.get();
int ival = ((int) b) & 0xff;
char c = (char) ival;
// Mantener bonita la alineación tabular
si (yo < 10)
Sistema.out.print(" ");
//Imprimir número de índice
System.out.print(" " + i + ": ");
// Algún día llegará una salida mejor formateada...
si (val < 16)
System.out.print("0");
// Imprime el valor hexadecimal del byte
System.out.print(Integer.toHexString(ival));
// Si el byte parece ser el valor de un
// carácter imprimible, imprimirlo. No hay garantía.
// así será.
if (Character.isWhitespace(c) || ​​​​Character.isISOControl(c)) {
System.out.println("");
} demás {
System.out.println(" (" + c + ")");
}
}
System.out.println("");
}
}

Juego de caracteres: ISO-8859-1
Entrada: ?Ma?ana?
Codificado:
0:20
1: novio (?)
2: 4d (M)
3:61(a)
4: f1 (?)
5:61(a)
6: 6e(n)
7:61(a)
8:3f (?)

Juego de caracteres: UTF-8
Entrada: ?Ma?ana?
Codificado:
0:20
1: c2 (?)
2: novio (?)
3: 4d (M)
4:61(a)
5: c3 (?)
6: b1 (±)
7:61(a)
8: 6e(n)
9:61(a)
10:3f (?)

Juego de caracteres: UTF-16BE
Entrada: ?Ma?ana?
Codificado:
0:00
1:20
2:00
3: novio (?)
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 (?)

Juego de caracteres: UTF-16LE
Entrada: ?Ma?ana?
Codificado:
0:20
1:00
2: novio (?)
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

Juego de caracteres: UTF-16
Entrada: ?Ma?ana?
Codificado:
0: fe (?)
1:ff (?)
2:00
3:20
4:00
5: novio (?)
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 (?)

paquete java.nio.charset;
clase abstracta pública Charset implementa Comparable
{
booleano estático público isSupported (String charsetName)
Juego de caracteres estático público para nombre (String charsetName)
SortedMap estático público disponibleCharsets()
nombre de cadena final pública()
público final Establecer alias()
cadena pública displayName()
cadena pública displayName (localización local)
público final booleano está registrado ()
canEncode booleano público()
resumen público CharsetEncoder newEncoder();
Codificación pública final de ByteBuffer (CharBuffer cb)
codificación ByteBuffer final pública (String str)
resumen público CharsetDecoder newDecoder();
Decodificación pública final de CharBuffer (ByteBuffer bb)
El booleano abstracto público contiene (Charset cs);
público final booleano es igual (Objeto ob)
public final int compareTo (Objeto ob)
código hash int final público ()
Cadena final pública toString()
}

clase abstracta pública Charset implementa Comparable
{
// Este es un listado parcial de API
El booleano abstracto público contiene (Charset cs);
público final booleano es igual (Objeto ob)
public final int compareTo (Objeto ob)
código hash int final público ()
Cadena final pública toString()
}

paquete java.nio.charset;
clase abstracta pública CharsetEncoder
{
// Este es un listado parcial de API
canEncode booleano público (char c)
canEncode booleano público (CharSequence cs)
}

paquete java.nio.charset;
clase pública CoderResult {
CoderResult final estático público DESBORDAMIENTO
CoderResult final estático público UNDERFLOW
booleano público esUnderflow()
booleano público isOverflow()
<span style="white-space:pre"> </span>público booleano isError()
booleano público está mal formado()
booleano público es inasignable()
longitud int pública()
CoderResult estático público malformadoForLength (longitud int)
CoderResult estático público unmappableForLength (longitud int)
<span style="white-space:pre"> </span>public void throwException() lanza CharacterCodingException
}

paquete java.nio.charset;
clase abstracta pública CharsetDecoder
{
// Este es un listado parcial de API
reinicio público final de CharsetDecoder()
Decodificación pública final de CharBuffer (ByteBuffer en)
lanza CharacterCodingException
Decodificación pública final de CoderResult (ByteBuffer entra, CharBuffer sale,
final booleano de entrada)
Descarga pública final de CoderResult (fuera CharBuffer)
}

paquete com.ronsoft.books.nio.charset;

importar java.nio.*;
importar java.nio.charset.*;
importar java.nio.channels.*;
importar java.io.*;

/**
* Pruebe la decodificación del juego de caracteres.
*
* @autor Ron Hitchens ([email protected])
*/
clase pública CharsetDecode {
/**
* Pruebe la decodificación del juego de caracteres en el caso general, detectando y manejando el búfer
* sub/desbordamiento y vaciado del estado del decodificador al final de la entrada de este código.
* lee desde stdin y decodifica el flujo de bytes codificado en ASCII en caracteres.
* Los caracteres decodificados se escriben en la salida estándar. Esto es efectivamente un 'gato' para.
* Ingrese archivos ASCII, pero se podría usar otra codificación de juego de caracteres simplemente
*especificándolo en la línea de comando.
*/
public static void main(String[] argv) lanza IOException {
// El juego de caracteres predeterminado es ASCII estándar
Cadena nombre_charset = "ISO-8859-1";
// El nombre del juego de caracteres se puede especificar en la línea de comando
si (argv. longitud > 0) {
nombrejuegochars = argv[0];
}
// Envuelve un canal alrededor de la entrada estándar, envuelve un canal alrededor de la salida estándar,
// busca el Charset nombrado y lo pasa al método deco de.
// Si el juego de caracteres nombrado no es válido, se produce una excepción de tipo
// Se lanzará una excepción UnsupportedCharsetException.
decodeChannel(Channels.newChannel(System.in), nuevo OutputStreamWriter(
System.out), Charset.forName(charsetName));
}

/**
* Método estático de propósito general que lee bytes de un canal, decodifica
* ellos según
*
* @param fuente
* Un objeto ReadableByteChannel que se leerá en EOF como un
* fuente de bytes codificados.
* @param escritor
* Un objeto Writer en el que se escribirán los caracteres decodificados.
* @param juego de caracteres
* Un objeto Charset, cuyo CharsetDecoder se utilizará para hacer el
* decodificación del juego de caracteres Java NIO 206.
*/
decodeChannel vacío estático público (fuente ReadableByteChannel, escritor,
Charset charset) arroja UnsupportedCharsetException, IOException {
// Obtener una instancia de decodificador del Charset
Decodificador CharsetDecoder = charset.newDecoder();
// Dile al decodificador que reemplace los caracteres incorrectos con la marca predeterminada
decodificador.onMalformedInput(CodingErrorAction.REPLACE);
decoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
// Asigna tamaños de buffer de entrada y salida radicalmente diferentes
// para fines de prueba
ByteBuffer bb = ByteBuffer.allocateDirect(16 * 1024);
CharBuffer cb = CharBuffer.allocate(57);
// El búfer comienza vacío; indica que se necesita entrada
Resultado de CoderResult = CoderResult.UNDERFLOW;
booleano eof = falso;
mientras (!eof) {
// Desbordamiento insuficiente del búfer de entrada; el decodificador quiere más entradas;
si (resultado == CoderResult.UNDERFLOW) {
// el decodificador consume toda la entrada, prepárese para recargar
bb.clear();
// Llene el búfer de entrada y busque EOF;
eof = (fuente.read(bb) == -1);
//Preparar el buffer para lectura por decodificador
bb.flip();
}
// Decodifica bytes de entrada para generar caracteres; pasa el indicador EOF;
resultado = decodificador.decodificar(bb, cb, eof);
// Si el buffer de salida está lleno, drena la salida
si (resultado == CoderResult.OVERFLOW) {
drenajeCharBuf(cb, escritor);
}
}
// Elimina cualquier estado restante del decodificador, teniendo cuidado
// para detectar desbordamientos del buffer de salida
mientras (decoder.flush(cb) == CoderResult.OVERFLOW) {
drenajeCharBuf(cb, escritor);
}
// Drena los caracteres restantes en el buffer de salida
drenajeCharBuf(cb, escritor);
// Cerrar el canal; enviar todos los datos almacenados en el búfer a la salida estándar.
fuente.close();
escritor.flush();
}

/**
* Método auxiliar para drenar el búfer de caracteres y escribir su contenido en el dado
* Objeto de escritura Al regresar, el búfer está vacío y listo para ser rellenado.
*
* @param cb
* Un CharBuffer que contiene caracteres para escribir.
* @param escritor
* Un objeto Writer para consumir los caracteres en cb.
*/
drenaje vacío estáticoCharBuf (CharBuffer cb, escritor escritor) lanza IOException {
cb.flip(); // Preparar el búfer para drenar
// Esto escribe los caracteres contenidos en CharBuffer pero
// en realidad no modifica el estado del búfer.
// Si las llamadas a get() estaban agotando el buffer de caracteres,
// puede que sea necesario un bucle aquí.
si (cb.hasRemaining()) {
escritor.write(cb.toString());
}
cb.clear(); // Prepara el buffer para llenarlo nuevamente
}
}

paquete com.ronsoft.books.nio.charset;

importar java.nio.CharBuffer;
importar java.nio.ByteBuffer;
importar java.nio.charset.Charset;
importar java.nio.charset.CharsetEncoder;
importar java.nio.charset.CharsetDecoder;
importar java.nio.charset.CoderResult;
importar java.util.Map;
importar java.util.Iterator;
importar java.io.Writer;
importar java.io.PrintStream;
importar java.io.PrintWriter;
importar java.io.OutputStreamWriter;
importar java.io.BufferedReader;
importar java.io.InputStreamReader;
importar java.io.FileReader;

/**
* Una implementación Charset que realiza la codificación Rot13 es una.
* algoritmo de ofuscación de texto simple que cambia los caracteres alfabéticos en 13
* para que 'a' se convierta en 'n', 'o' se convierta en 'b', etc. Este algoritmo se popularizó
* por los foros de discusión de Usenet hace muchos años para enmascarar palabras obscenas, ocultar
* respuestas a preguntas, etc. El algoritmo Rot13 es simétrico y se aplica.
* el texto codificado por Rot13 le dará el original
* texto descifrado.
*
* Aplicar esta codificación Charset a un flujo de salida hará que todo lo que
* escribir en esa secuencia para que se codifique en Rot13 a medida que se escribe y se aplica.
* a un flujo de entrada hace que los datos leídos se descifren en Rot13 a medida que se leen.
*
* @autor Ron Hitchens ([email protected])
*/
clase pública Rot13Charset extiende Charset {
// el nombre de la codificación del juego de caracteres base a la que delegamos
Cadena final estática privada BASE_CHARSET_NAME = "UTF-8";
// Maneja el conjunto de caracteres real que usaremos para la transcodificación entre
// caracteres y bytes Hacer esto nos permite aplicar el Rot13.
// algoritmo para codificaciones de conjuntos de caracteres multibyte. Pero solo el
// Los caracteres alfa ASCII se rotarán, independientemente de la codificación base.
Juego de caracteres baseCharset;

/**
* Constructor para el conjunto de caracteres Rot13 Llame al constructor de la superclase.
* pasar los nombres por los que seremos conocidos. Luego guardar una referencia al.
* delegado Charset.
*/
protected Rot13Charset (String canonical, String [] alias) {
super(canónico, alias);
// Guarda el juego de caracteres base al que estamos delegando
baseCharset = Charset.forName(BASE_CHARSET_NAME);
}

//------------------------------------------------ ----------
/**
* Llamado por los usuarios de este Charset para obtener un codificador.
* crea una instancia de una clase privada (definida a continuación) y la pasa
* un codificador del Charset base.
*/
público CharsetEncoder nuevoEncoder() {
devolver nuevo Rot13Encoder (esto, baseCharset.newEncoder());
}

/**
* Llamado por los usuarios de este Charset para obtener un decodificador.
* crea una instancia de una clase privada (definida a continuación) y la pasa
* un decodificador del Charset base.
*/
público CharsetDecoder nuevoDecodificador() {
devolver nuevo Rot13Decoder (esto, baseCharset.newDecoder());
}

/**
* Este método debe implementarse mediante Charsets concretos. Siempre decimos que no.
* que es seguro.
*/
booleano público contiene (juego de caracteres cs) {
retorno (falso);
}

/**
* Rutina común para rotar todos los caracteres alfa ASCII en el dado
* CharBuffer por 13. Tenga en cuenta que este código compara explícitamente las partes superior y
* caracteres ASCII en minúscula en lugar de utilizar los métodos
* Character.isLowerCase y Character.isUpperCase Esto se debe a que.
* El esquema de rotación por 13 solo funciona correctamente para los caracteres alfabéticos de
* el juego de caracteres ASCII y esos métodos pueden devolver verdadero para Unicode no ASCII
* caracteres.
*/
rot13 vacío privado (CharBuffer cb) {
for (int pos = cb.posición(); pos < cb.limit(); pos++) {
char c = cb.get(pos);
char a = '/u0000';
// ¿Es alfa minúscula?
si ((c >= 'a') && (c <= 'z')) {
a = 'a';
}
// ¿Es alfa mayúscula?
si ((c >= 'A') && (c <= 'Z')) {
a = 'A';
}
// Si es así, tiralo por 13
si (a != '/u0000') {
c = (char) ((((c - a) + 13) % 26) + a);
cb.put(pos, c);
}
}
}

//------------------------------------------------ --------
/**
* La implementación del codificador para Rot13 Chars et.
* la clase de decodificador coincidente a continuación también debe anular los métodos "impl",
* como implOnMalformedInput() y realizar llamadas de paso al
* Objeto baseEncoder. Que se deja como ejercicio para el hacker.
*/
la clase privada Rot13Encoder extiende CharsetEncoder {
baseEncoder CharsetEncoder privado;

/**
* Constructor, llama al constructor de superclase con el objeto Charset
* y los tamaños de codificaciones del codificador delegado.
*/
Rot13Encoder(Charset cs, CharsetEncoder baseEncoder) {
super(cs, baseEncoder.averageBytesPerChar(), baseEncoder
.maxBytesPerChar());
this.baseEncoder = baseEncoder;
}

/**
* Implementación del bucle de codificación Primero, aplicamos el Rot13.
* algoritmo de codificación al CharBuffer, luego reinicie el codificador para
* el Charset base y llama a su método encode() para hacer lo real
* codificación. Es posible que esto no funcione correctamente con conjuntos de caracteres no latinos.
* El CharBuffer ingresado puede ser de solo lectura o reutilizado por la persona que llama para
* otros propósitos, por lo que lo duplicamos y aplicamos la codificación Rot13 al
* copiar. QUEREMOS avanzar la posición del búfer de entrada a.
* reflejan los caracteres consumidos.
*/
CoderResult protegido encodeLoop (CharBuffer cb, ByteBuffer bb) {
CharBuffer tmpcb = CharBuffer.allocate(cb.remaining());
mientras (cb.hasRemaining()) {
tmpcb.put(cb.get());
}
tmpcb.rebobinar();
rot13(tmpcb);
baseEncoder.reset();
CoderResult cr = baseEncoder.encode(tmpcb, bb, true);
// Si se produce un error o se desborda la salida, debemos ajustar
// la posición del buffer de entrada para que coincida con lo que
// realmente se consumió del búfer temporal.
// desbordamiento insuficiente (todas las entradas consumidas), esto no es operativo.
cb.posición(cb.posición() - tmpcb.restante());
retorno(cr);
}
}

//------------------------------------------------ --------
/**
* La implementación del decodificador para Rot13 Charset.
*/
la clase privada Rot13Decoder extiende CharsetDecoder {
baseDecoder CharsetDecoder privado;

/**
* Constructor, llama al constructor de superclase con el objeto Charset
* y pasar los valores de caracteres/bytes del decodificador delegado.
*/
Rot13Decoder(Charset cs, CharsetDecoder baseDecoder) {
super(cs, baseDecoder.averageCharsPerByte(), baseDecoder
.maxCharsPerByte());
this.baseDecoder = baseDecoder;
}

/**
* Implementación del bucle de decodificación Primero, reiniciamos el decodificador.
* el juego de caracteres base, luego llámelo para decodificar los bytes en caracteres,
* guardar el código de resultado. Luego, el CharBuffer se decodifica con el
* Se devuelve el algoritmo Rot13 y el código de resultado. Es posible que esto no funcione.
* correctamente para conjuntos de caracteres no latinos.
*/
CoderResult protegido decodeLoop (ByteBuffer bb, CharBuffer cb) {
baseDecoder.reset();
Resultado de CoderResult = baseDecoder.decode(bb, cb, true);
rot13(cb);
retorno (resultado);
}
}

//------------------------------------------------ --------
/**
* Prueba unitaria para el conjunto de caracteres Rot13. Este main( ) abrirá y leerá una entrada.
* Archivo si se nombra en la línea de comandos, o stdin si no se proporcionan args, y
* Escriba el contenido a STDOT a través de la codificación de charset x -ROT13.
* El "cifrado" implementado por el algoritmo ROT13 es simétrico.
* En un archivo de texto sencillo, como el código fuente de Java, por ejemplo, emitirá un
* Versión revuelta.
* Documento de texto simple original.
*/
public static void main (string [] argv) lanza la excepción {
BufferedReader en;
if (argv. longitud> 0) {
// Abra el archivo con nombre
in = new BufferedReader (nuevo FileReader (argv [0]));
} demás {
// envuelve un lector de topes alrededor de Stdin
in = new BufferedReader (new InputStreamReader (System.in));
}
// Crear un PintStream que use la codificación ROT13
PrintStream out = new PrintStream (System.out, False, "X -ROT13");
Cadena s = nula;
// Lea todas las entradas y escríbala en la salida.
// A medida que los datos pasan a través de PrintStream,
// estará codificado por ROT13.
while ((s = in.readline ())! = null) {
out.println (s);
}
salida.flush();
}
}

paquete com.ronsoft.books.nio.charset;

import java.nio.charset.charset;
import java.nio.charset.spi.charsetProvider;
importar java.util.HashSet;
import java.util.iterator;

/**
* Una clase CharsetProvider que pone a disposición los Charsets proporcionados por
* Ronsoft.
* No es un Charset IANA registrado, por lo que su nombre comienza con "X-" para evitar el nombre
* enfrentamientos con charsets oficiales.
*
* Para activar este CharsetProvider, es necesario agregar un archivo al
* classpath del tiempo de ejecución JVM en la siguiente ubicación:
* Meta-Inf/Services/java.nio.charsets.spi.charsetProvider
*
* Ese archivo debe contener una línea con el nombre totalmente calificado de esta clase en
* Una línea por sí misma: com.ronsoft.books.nio.charset.ronsoftcharsetprovider java
* NIO 216
*
* Consulte la página Javadoc para java.nio.charsets.spi.charsetProvider para completar
* detalles.
*
* @author Ron Hitchens ([email protected])
*/
clase pública RonsoftcharsetProvider extiende CharsetProvider {
// El nombre del charset que proporcionamos
String final estática privada Charset_name = "X-ROT13";
// un mango al objeto Charset
Charset privado ROT13 = nulo;

/**
* Constructor, instanciar un objeto Charset y guardar la referencia.
*/
public ronsoftcharsetProvider () {
this.rot13 = new Rot13CharSet (Charset_Name, nueva cadena [0]);
}

/**
* Llamado por métodos estáticos Charset para encontrar un charset en particular.
* Es el nombre de este charset (no tenemos ningún alias) y luego devuelve el
* ROT13 Charset, de lo contrario regresa nulo.
*/
public Charset CharsetForname (String CharSetName) {
if (charsetName.equalSignorEcase (charset_name)) {
return (rot13);
}
return (nulo);
}

/**
* Devuelve un iterador sobre el conjunto de objetos de charset que proporcionamos.
*
* @return Un objeto iterador que contiene referencias a todos los charset
* Objetos proporcionados por esta clase.
*/
Public Iterator <Harset> charsets () {
Hashset <Harset> set = new Hashset <Harset> (1);
set.add (rot13);
return (set.iterator ());
}
}

Agregar x -ROT13 a la lista de set de caracteres en el ejemplo 6-1 produce esta salida adicional:

Charset: X-Rot13
Entrada: żmaana?
Codificado:
0: C2 (ż)
1: BF (ż)
2: 5a (z)
3: 6e (n)
4: C3 (ă)
5: B1 (±)
6: 6e (n)
7:61 (a)
8: 6e (n)
9: 3f (?)