Java With Us

Utilisation étendue de la table ASCII en Java

Updated on 2026-04-20 Reviewed by the Java With Us editorial team

La table ASCII associe 128 caractères (de 0 à 127) à leurs codes numériques. La table ASCII étendue va jusqu'à 255 et ajoute les caractères latins accentués et divers symboles. En Java, ces codes se manipulent aisément via le type char, mais quelques pièges subsistent avec Unicode.

Conversion char ↔ int

Un char en Java est un entier non signé sur 16 bits. L'ASCII occupe les valeurs 0 à 127, l'ASCII étendu 128 à 255.

char lettre = 'A';
int code = lettre;         // promotion implicite → 65
System.out.println((int) lettre); // 65

int valeur = 65;
char c = (char) valeur;    // cast explicite → 'A'

Afficher la table ASCII complète

public class TableAscii {
    public static void main(String[] args) {
        for (int i = 32; i < 127; i++) { // caractères imprimables
            System.out.printf("%3d : %c%n", i, (char) i);
        }
    }
}

// Sortie :
//  32 :   (espace)
//  33 : !
//  34 : "
//  ... jusqu'à 126 : ~

Les codes 0 à 31 sont des caractères de contrôle non imprimables (TAB, LF, CR, BEL, etc.). Le code 127 est DEL.

Table ASCII étendue (128 à 255)

La plage 128-255 n'a pas de signification universelle — elle dépend de l'encodage. L'ASCII étendu le plus courant en Europe occidentale est ISO-8859-1 (Latin-1) :

System.out.println((char) 128); // dépend de l'encodage de sortie
System.out.println((char) 233); // 'é' en ISO-8859-1 / Latin-1
System.out.println((char) 224); // 'à' en ISO-8859-1

En Windows-1252, en MacRoman ou en CP437 (DOS), ces mêmes codes représentent des caractères différents — c'est la source classique du "mojibake".

Convertir une chaîne en tableau de codes

String s = "Hello";
char[] chars = s.toCharArray();
int[] codes = s.chars().toArray();

for (int code : codes) System.out.print(code + " ");
// 72 101 108 108 111

Détecter si un caractère est ASCII

public static boolean estAscii(char c) {
    return c <= 127;
}

public static boolean estAsciiEtendu(char c) {
    return c <= 255;
}

public static boolean estAsciiImprimable(char c) {
    return c >= 32 && c < 127;
}

La classe Character — bien plus puissante

Pour des tests au-delà de l'ASCII (Unicode complet), préférez la classe Character :

Character.isLetter('é');     // true
Character.isDigit('7');      // true
Character.isWhitespace(' '); // true
Character.isUpperCase('A');  // true
Character.toLowerCase('A');  // 'a'

Conversion entre encodages

Si vous recevez des octets dans un encodage ASCII étendu et devez les convertir en chaîne Java (UTF-16 en interne) :

byte[] bytes = { (byte) 233, (byte) 224, (byte) 231 };
String s = new String(bytes, java.nio.charset.StandardCharsets.ISO_8859_1);
System.out.println(s); // éàç

Inverse — obtenir les octets dans un encodage donné :

byte[] out = "café".getBytes(java.nio.charset.StandardCharsets.ISO_8859_1);
// out = { 99, 97, 102, -23 }  (-23 = 233 en non signé)

Pièges courants

Char signé en Java — non

En Java, char est non signé (0 à 65535). Pas de valeur négative. Mais byte est signé (-128 à 127). Convertir un byte > 127 en char nécessite d'ajouter 256 :

byte b = (byte) 233; // stocké comme -23
char c = (char) (b & 0xFF); // & 0xFF force la lecture non signée
System.out.println((int) c); // 233

Concaténation vs addition

char c = 'A';
System.out.println(c + 1);       // 66 — addition numérique
System.out.println("" + c + 1);  // "A1" — concaténation de String

Et Unicode dans tout ça ?

Les 128 caractères ASCII sont identiques à Unicode pour les 128 premiers code points (U+0000 à U+007F). L'ASCII est un sous-ensemble parfait d'Unicode.

L'ASCII étendu (128-255) correspond à Latin-1 Supplément en Unicode (U+0080 à U+00FF). Au-delà, Unicode définit ~150 000 caractères couvrant toutes les écritures humaines.

Pour du texte international (émojis, CJK), utilisez les méthodes codePoints() de String plutôt que chars(), pour traiter correctement les paires de substitution.

Usage pratique

Quelques cas où jouer avec les codes ASCII est encore utile :

  • Chiffres : c - '0' convertit '0'-'9' en 0-9.
  • Majuscule/minuscule : c + 32 passe 'A'-'Z' en 'a'-'z'.
  • Validation stricte : accepter uniquement les caractères ASCII dans un identifiant.
  • Protocoles bas niveau (HTTP, SMTP) qui sont définis en ASCII.

Pour tout le reste — affichage utilisateur, fichiers, données externes — travaillez en Unicode UTF-8. L'ASCII reste un outil mental utile pour comprendre ce que Java fait sous le capot, mais rarement un choix d'encodage au XXIe siècle.

Related articles