Explication détaillée de la mise en œuvre du codage et du décodage des caractères Java

paquet com.ronsoft.books.nio.charset ;

importer java.nio.charset.Charset ;
importer java.nio.ByteBuffer ;

/**
* Test d'encodage Charset Exécutez la même chaîne d'entrée, qui en contient.
* Caractères non-ASCII, via plusieurs encodeurs Charset et vidage de l'hexadécimal
* valeurs des séquences d'octets résultantes.
*
* @auteur Ron Hitchens ([email protected])
*/
classe publique EncodeTest {
public static void main(String[] argv) lève une exception {
// Voici la séquence de caractères à encoder
Entrée de chaîne = "/u00bfMa/u00f1ana ?";
// la liste des jeux de caractères avec lesquels encoder
String[] charsetNames = { "US-ASCII", "ISO-8859-1", "UTF-8",
"UTF-16BE", "UTF-16LE", "UTF-16" // , "X-ROT13"
} ;
pour (int i = 0; i < charsetNames.length; i++) {
doEncode(Charset.forName(charsetNames[i]), entrée);
}
}

/**
* Pour un jeu de caractères et une chaîne d'entrée donnés, encodez les caractères et imprimez le
* Codage d'octets résultant sous une forme lisible.
*/
private static void doEncode (Charset cs, entrée de chaîne) {
ByteBuffer bb = cs.encode(entrée);
System.out.println("Charset: " + cs.name());
System.out.println(" Entrée : " + entrée);
System.out.println("Encodé : ");
pour (int i = 0; bb.hasRemaining(); i++) {
int b = bb.get();
int ival = ((int) b) & 0xff;
char c = (char)ival;
// Gardez un joli alignement tabulaire
si (i < 10)
System.out.print(" ");
//Imprimer le numéro d'index
System.out.print(" " + i + ": ");
// Une sortie mieux formatée arrivera un jour...
si (val < 16)
System.out.print("0");
// Affiche la valeur hexadécimale de l'octet
System.out.print(Integer.toHexString(ival));
// Si l'octet semble être la valeur d'un
// caractère imprimable, imprimez-le Aucune garantie.
// ce sera.
if (Character.isWhitespace(c) || ​​​​Character.isISOControl(c)) {
System.out.println("");
} autre {
System.out.println(" (" + c + ")");
}
}
System.out.println("");
}
}

Jeu de caractères : ISO-8859-1
Entrée : Ma ana ?
Codé :
0:20
1 : petit ami (?)
2 : 4j (M)
3:61(a)
4 : f1 (?)
5:61(a)
6 : 6e(n)
7:61(a)
8 : 3f (?)

Jeu de caractères : UTF-8
Entrée : Ma ana ?
Codé :
0:20
1 : c2 (?)
2 : petit ami (?)
3 : 4j (M)
4:61(a)
5 : c3 (?)
6 : b1 (±)
7:61(a)
8 : 6e(n)
9:61(a)
10h30 (?)

Jeu de caractères : UTF-16BE
Entrée : Ma ana ?
Codé :
0:00
1:20
14h00
3 : petit ami (?)
16h00
5 : 4j (M)
6h00
7:61(a)
8h00
9 : f1 (?)
10h00
11:61(a)
12h00
13 : 6e(n)
14h00
15 : 61 (a)
16h00
17 : 3f (?)

Jeu de caractères : UTF-16LE
Entrée : Ma ana ?
Codé :
0:20
1h00
2 : petit ami (?)
15h00
4 : 4j (M)
17h00
6:61(a)
7h00
8 : f1 (?)
9h00
10:61(a)
11h00
12 : 6e(n)
13h00
14 : 61 (a)
15h00
16 : 3f (?)
17h00

Jeu de caractères : UTF-16
Entrée : Ma ana ?
Codé :
0 : fé (?)
1 : ff (?)
14h00
15h20
16h00
5 : petit ami (?)
6h00
7 : 4j (M)
8h00
9:61(a)
10h00
11 : f1 (?)
12h00
13 : 61 (a)
14h00
15 : 6e(n)
16h00
17 : 61 (a)
18h00
19 : 3f (?)

paquet java.nio.charset ;
classe abstraite publique Charset implémente Comparable
{
public statique booléen isSupported (String charsetName)
Charset statique public pourName (String charsetName)
public statique SortedMap disponibleCharsets()
nom de chaîne final public ()
public final Définir les alias()
chaîne publique displayName()
public String displayName (Locale locale)
public final booléen isRegistered()
public booléen canEncode()
public abstrait CharsetEncoder newEncoder();
encodage public final ByteBuffer (CharBuffer cb)
encodage public final ByteBuffer (String str)
public abstrait CharsetDecoder newDecoder();
décodage public final de CharBuffer (ByteBuffer bb)
public abstract boolean contient (Charset cs);
public final booléen égal (Objet ob)
public final int compareTo (Objet ob)
public final int hashCode()
chaîne finale publique toString()
}

classe abstraite publique Charset implémente Comparable
{
// Ceci est une liste partielle d'API
public abstract boolean contient (Charset cs);
public final booléen égal (Objet ob)
public final int compareTo (Objet ob)
public final int hashCode()
chaîne finale publique toString()
}

paquet java.nio.charset ;
classe abstraite publique CharsetEncoder
{
// Ceci est une liste partielle d'API
public booléen canEncode (char c)
canEncode booléen public (CharSequence cs)
}

paquet java.nio.charset ;
classe publique CoderResult {
public statique final CoderResult OVERFLOW
CoderResult final statique public UNDERFLOW
public booléen isUnderflow()
public booléen isOverflow()
<span style="white-space:pre"> </span>booléen public isError()
public booléen isMalformed()
public booléen isUnmappable()
public int longueur()
CoderResult statique public malformedForLength (longueur int)
coderResult statique public unmappableForLength (longueur int)
<span style="white-space:pre"> </span>public void throwException() lance CharacterCodingException
}

paquet java.nio.charset ;
classe abstraite publique CharsetDecoder
{
// Ceci est une liste partielle d'API
réinitialisation publique finale du CharsetDecoder ()
décodage public final du CharBuffer (ByteBuffer in)
lance CharacterCodingException
décodage public final de CoderResult (ByteBuffer in, CharBuffer out,
booléen endOfInput)
vidage final public de CoderResult (CharBuffer out)
}

paquet com.ronsoft.books.nio.charset ;

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

/**
* Testez le décodage du jeu de caractères.
*
* @auteur Ron Hitchens ([email protected])
*/
classe publique CharsetDecode {
/**
* Tester le décodage du jeu de caractères dans le cas général, détection et gestion du tampon
* sous/débordement et vidage de l'état du décodeur à la fin de l'entrée de ce code.
* lit depuis stdin et décode le flux d'octets codé en ASCII en caractères.
* Les caractères décodés sont écrits sur la sortie standard. Il s'agit en fait d'un "chat" pour.
* saisissez des fichiers ascii, mais un autre codage de jeu de caractères pourrait être utilisé simplement
* en le spécifiant sur la ligne de commande.
*/
public static void main(String[] argv) lance IOException {
// Le jeu de caractères par défaut est ASCII standard
Chaîne charsetName = "ISO-8859-1" ;
// Le nom du jeu de caractères peut être spécifié sur la ligne de commande
if (argv. longueur > 0) {
charsetName = argv[0];
}
// Enroulez un canal autour de stdin, enroulez un canal autour de stdout,
// trouve le Charset nommé et le transmet à la méthode deco de.
// Si le jeu de caractères nommé n'est pas valide, une exception de type
// UnsupportedCharsetException sera levée.
decodeChannel (Channels.newChannel (System.in), nouveau OutputStreamWriter (
System.out), Charset.forName(charsetName));
}

/**
* Méthode statique à usage général qui lit les octets d'un canal, décode
*les selon
*
* Source @param
* Un objet ReadableByteChannel qui sera lu dans EOF en tant que
* source des octets codés.
* @param écrivain
* Un objet Writer dans lequel les caractères décodés seront écrits.
* @param jeu de caractères
* Un objet Charset, dont CharsetDecoder sera utilisé pour effectuer le
* Décodage du jeu de caractères Java NIO 206.
*/
public static void decodeChannel (source ReadableByteChannel, écrivain Writer,
Charset charset) lance UnsupportedCharsetException, IOException {
// Récupère une instance de décodeur à partir du Charset
CharsetDecoder décodeur = charset.newDecoder();
// Dites au décodeur de remplacer les mauvais caractères par la marque par défaut
decoder.onMalformedInput(CodingErrorAction.REPLACE);
decoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
// Alloue des tailles de tampon d'entrée et de sortie radicalement différentes
// à des fins de tests
ByteBuffer bb = ByteBuffer.allocateDirect(16 * 1024);
CharBuffer cb = CharBuffer.allocate(57);
// Le tampon commence vide ; indique qu'une entrée est nécessaire
Résultat CoderResult = CoderResult.UNDERFLOW ;
booléen eof = faux ;
tandis que (!eof) {
// Dépassement excessif du tampon d'entrée ; le décodeur veut plus d'entrées.
si (résultat == CoderResult.UNDERFLOW) {
// le décodeur consomme toutes les entrées, préparez-vous à recharger
bb.clear();
// Remplit le tampon d'entrée ; surveille EOF
eof = (source.read(bb) == -1);
// Prépare le buffer pour la lecture par le décodeur
bb.flip();
}
// Décode les octets d'entrée en caractères de sortie ; passe l'indicateur EOF
résultat = décodeur.decode(bb, cb, eof);
// Si le tampon de sortie est plein, draine la sortie
si (résultat == CoderResult.OVERFLOW) {
drainCharBuf(cb, écrivain);
}
}
// Vide tout état restant du décodeur, en faisant attention
// pour détecter les dépassements de tampon de sortie
while (decoder.flush(cb) == CoderResult.OVERFLOW) {
drainCharBuf(cb, écrivain);
}
// Vide tous les caractères restants dans le tampon de sortie
drainCharBuf(cb, écrivain);
// Ferme le canal ; envoie toutes les données mises en mémoire tampon vers la sortie standard.
source.close();
écrivain.flush();
}

/**
* Méthode d'assistance pour vider le tampon de caractères et écrire son contenu dans le fichier donné
* Objet Writer Au retour, le tampon est vide et prêt à être rempli.
*
* @paramcb
* Un CharBuffer contenant des caractères à écrire.
* @param écrivain
* Un objet Writer pour consommer les caractères dans cb.
*/
static void drainCharBuf (CharBuffer cb, Writer Writer) lance IOException {
cb.flip(); // Préparer le tampon pour le drainage
// Ceci écrit les caractères contenus dans le CharBuffer mais
// ne modifie pas réellement l'état du tampon.
// Si le tampon de caractères était vidé par les appels à get( ),
// une boucle pourrait être nécessaire ici.
si (cb.hasRemaining()) {
écrivain.write(cb.toString());
}
cb.clear(); // Prépare le tampon à remplir à nouveau
}
}

paquet com.ronsoft.books.nio.charset ;

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

/**
* Une implémentation de Charset qui effectue l'encodage Rot13 est un encodage Rot-13.
* algorithme simple d'obscurcissement du texte qui décale les caractères alphabétiques de 13
* pour que 'a' devienne 'n', 'o' devienne 'b', etc. Cet algorithme a été popularisé
* par les forums de discussion Usenet il y a de nombreuses années pour masquer les vilains mots, cacher
* réponses aux questions, etc. L'algorithme Rot13 est symétrique, s'appliquant.
* le texte brouillé par Rot13 vous donnera l'original
*texte non crypté.
*
* L'application de cet encodage Charset à un flux de sortie entraînera tout ce que vous
* écrivez sur ce flux pour que Rot13 soit brouillé tel qu'il est écrit et appliqué.
* L'envoi dans un flux d'entrée entraîne le déchiffrement Rot13 des données lues au fur et à mesure de leur lecture.
*
* @auteur Ron Hitchens ([email protected])
*/
la classe publique Rot13Charset étend Charset {
// le nom du codage de jeu de caractères de base auquel nous déléguons
Chaîne finale statique privée BASE_CHARSET_NAME = "UTF-8" ;
// Handle vers le vrai jeu de caractères que nous utiliserons pour le transcodage entre
// caractères et octets Faire cela nous permet d'appliquer le Rot13.
// algorithme pour les encodages de jeux de caractères multioctets Mais uniquement le.
// Les caractères alpha ASCII seront pivotés, quel que soit l'encodage de base.
Jeu de caractères baseCharset ;

/**
* Constructeur pour le jeu de caractères Rot13 Appelez le constructeur de superclasse pour.
* transmettez le(s) nom(s) sous lequel(s) nous serons connus. Enregistrez ensuite une référence au(x) nom(s) sous lequel(s) nous serons connus.
*délégué Charset.
*/
protected Rot13Charset (String canonique, String[] alias) {
super(canonique, alias);
// Enregistrez le jeu de caractères de base auquel nous déléguons
baseCharset = Charset.forName(BASE_CHARSET_NAME);
}

//------------------------------------------------ ----------
/**
* Appelé par les utilisateurs de ce Charset pour obtenir un encodeur cette implémentation.
* instancie une instance d'une classe privée (définie ci-dessous) et la transmet
* un encodeur du Charset de base.
*/
public CharsetEncoder newEncoder() {
return new Rot13Encoder(this, baseCharset.newEncoder());
}

/**
* Appelé par les utilisateurs de ce Charset pour obtenir un décodeur cette implémentation.
* instancie une instance d'une classe privée (définie ci-dessous) et la transmet
* un décodeur du Charset de base.
*/
public CharsetDecoder newDecoder() {
return new Rot13Decoder(this, baseCharset.newDecoder());
}

/**
* Cette méthode doit être implémentée par des Charsets concrets. Nous disons toujours non,
* ce qui est sûr.
*/
public boolean contient (Charset cs) {
retour (faux);
}

/**
* Routine commune pour faire pivoter tous les caractères alpha ASCII dans le format donné
* CharBuffer par 13. Notez que ce code compare explicitement les valeurs supérieures et supérieures.
* caractères ASCII minuscules plutôt que d'utiliser les méthodes
* Character.isLowerCase et Character.isUpperCase C'est parce que le
* Le système de rotation par 13 ne fonctionne correctement que pour les caractères alphabétiques de
* le jeu de caractères ASCII et ces méthodes peuvent renvoyer vrai pour Unicode non-ASCII
* caractères.
*/
private void rot13 (CharBuffer cb) {
pour (int pos = cb.position(); pos < cb.limit(); pos++) {
char c = cb.get(pos);
char a = '/u0000';
// Est-ce un alpha minuscule ?
si ((c >= 'a') && (c <= 'z')) {
une = 'une';
}
// Est-ce un alpha majuscule ?
si ((c >= 'A') && (c <= 'Z')) {
une = « A » ;
}
// Si c'est le cas, lancez-le de 13
si (a != '/u0000') {
c = (caractère) ((((c - a) + 13) % 26) + a);
cb.put(pos, c);
}
}
}

//------------------------------------------------ ---------
/**
* L'implémentation de l'encodeur pour Rot13 Chars et cette classe, et le
* La classe de décodeur correspondante ci-dessous doit également remplacer les méthodes "impl",
* comme implOnMalformedInput( ) et effectuez des appels relais au
* Objet baseEncoder. Cela reste un exercice pour le pirate informatique.
*/
la classe privée Rot13Encoder étend CharsetEncoder {
baseEncoder CharsetEncoder privé ;

/**
* Constructeur, appelez le constructeur de superclasse avec l'objet Charset
* et les tailles d'encodages de l'encodeur délégué.
*/
Rot13Encoder (Charset cs, CharsetEncoder baseEncoder) {
super(cs, baseEncoder.averageBytesPerChar(), baseEncoder
.maxBytesPerChar());
this.baseEncoder = baseEncoder;
}

/**
* Implémentation de la boucle d'encodage. Tout d'abord, nous appliquons le Rot13.
* algorithme de brouillage vers le CharBuffer, puis réinitialisez l'encodeur pour
* le jeu de caractères de base et appelez sa méthode encode() pour effectuer le véritable
* encodage Cela peut ne pas fonctionner correctement pour les jeux de caractères non latins.
* CharBuffer transmis peut être en lecture seule ou réutilisé par l'appelant pour
* à d'autres fins, nous le dupliquons et appliquons l'encodage Rot13 au
* copie Nous voulons avancer la position du tampon d'entrée à.
* reflètent les caractères consommés.
*/
CoderResult protégé encodeLoop (CharBuffer cb, ByteBuffer bb) {
CharBuffer tmpcb = CharBuffer.allocate(cb.remaining());
tandis que (cb.hasRemaining()) {
tmpcb.put(cb.get());
}
tmpcb.rewind();
rot13(tmpcb);
baseEncoder.reset();
CoderResult cr = baseEncoder.encode(tmpcb, bb, true);
// En cas d'erreur ou de débordement de sortie, nous devons ajuster
// la position du tampon d'entrée pour correspondre à quoi
// a vraiment été consommé à partir du tampon temporaire.
// underflow (toutes les entrées consommées), c'est un non-op.
cb.position(cb.position() - tmpcb.remaining());
return(cr);
}
}

//------------------------------------------------ ---------
/**
* L'implémentation du décodeur pour le jeu de caractères Rot13.
*/
la classe privée Rot13Decoder étend CharsetDecoder {
baseDecoder CharsetDecoder privé ;

/**
* Constructeur, appelez le constructeur de superclasse avec l'objet Charset
* et transmettez les valeurs caractères/octets du décodeur délégué.
*/
Rot13Decoder (Charset cs, CharsetDecoder baseDecoder) {
super(cs, baseDecoder.averageCharsPerByte(), baseDecoder
.maxCharsPerByte());
this.baseDecoder = baseDecoder;
}

/**
* Implémentation de la boucle de décodage Tout d'abord, nous réinitialisons le décodeur pour.
* le jeu de caractères de base, puis appelez-le pour décoder les octets en caractères,
* sauvegarde du code résultat Le CharBuffer est ensuite décrypté avec le
* L'algorithme Rot13 et le code de résultat sont renvoyés. Cela peut ne pas fonctionner.
* correctement pour les jeux de caractères non latins.
*/
protégé CoderResult decodeLoop (ByteBuffer bb, CharBuffer cb) {
baseDecoder.reset();
Résultat CoderResult = baseDecoder.decode(bb, cb, true);
ROT13 (CB);
retour (résultat);
}
}

// ------------------------------------------------ ---------
/**
* Test unitaire pour le Charset ROT13.
* Fichier s'il est nommé sur la ligne de commande, ou stdin si aucun args n'est fourni, et
* Écrivez le contenu à STDOUT via le codage du charset X -ROT13.
* "Encryption" implémenté par l'algorithme ROT13 est symétrique.
* Dans un fichier de texte clair, tel que le code source Java par exemple, publiera un
* Version brouillée.
* Document de texte brut original.
*/
public static void main (String [] argv) lance une exception {
BufferedReader dans;
if (argv. longueur> 0) {
// Ouvrez le fichier nommé
dans = new BufferedReader (nouveau FileReader (argv [0]));
} autre {
// enveloppe un BufferedReader autour de stdin
dans = new BufferedReader (new inputStreamReader (System.in));
}
// Créer un PrintStream qui utilise le codage ROT13
PrintStream out = new printStream (System.out, false, "x -rot13");
Chaîne s = nulle ;
// Lisez toutes les entrées et écrivez-la dans la sortie.
// au fur et à mesure que les données passent par le PrintStream,
// Ce sera encodé de ROT13.
while ((s = in.readline ())! = null) {
out.println (s);
}
out.flush();
}
}

package com.ronsoft.books.nio.charset;

import java.nio.charse.Charset;
import java.nio.charset.spi.charsetProvider;
importer java.util.HashSet ;
Importer java.util.iterator;

/**
* Une classe CharsetProvider qui rend disponible lessets fournis par
* Ronsoft.
* Pas un Charset Iana enregistré, donc son nom commence par "x-" pour éviter le nom
* se heurte à des caractères officiels.
*
* Pour activer ce charsetprovider, il est nécessaire d'ajouter un fichier au
* CLASSPATH de l'exécution JVM à l'emplacement suivant:
* Meta-Inf / Services / Java.nio.Charsets.spi.CharsetProvider
*
* Ce fichier doit contenir une ligne avec le nom entièrement qualifié de cette classe sur
* Une ligne en soi: com.ronsoft.books.nio.charse.RonsoftCharsetProvider Java
* Nio 216
*
* Voir la page Javadoc pour java.nio.charsets.spi.charsetprovider pour complet
* détails.
*
* @author Ron Hitchens ([email protected])
*/
classe publique RonsoftCharsetProvider étend CharsetProvider {
// le nom du charme que nous fournissons
chaîne finale statique privée charset_name = "x-rot13";
// une poignée de l'objet Charset
Charset privé Rot13 = null;

/**
* Constructeur, instanciez un objet de charme et enregistrez la référence.
*/
public ronsoftcharsetprovider () {
this.rot13 = new rot13Charset (charset_name, new String [0]);
}

/**
* Appelé par les méthodes statiques de Charset pour trouver un charme nommé particulier.
* C'est le nom de ce charet (nous n'avons pas d'alias) puis renvoie le
* Charset ROT13, else retourne null.
*/
public Charset charSetForname (String charSetName) {
if (charSetName.equalSignoreCase (charset_name)) {
retour (rot13);
}
retour (null);
}

/**
* Renvoyez un itérateur sur l'ensemble des objets de charme que nous fournissons.
*
* @return un objet Iterator contenant des références à tout le charme
* Objets fournis par cette classe.
*/
Iterator public <Charset> Charsets () {
HashSet <Sharset> set = new Hashset <Charset> (1);
set.add (rot13);
return (set.iterator ());
}
}

L'ajout de x -rot13 à la liste des jeux de caractères dans l'exemple 6-1 produit cette sortie supplémentaire:

Charset: X-Rot13
Entrée: żmaana?
Encodé:
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 (?)