Les caractères Java (char)

char est l'un des huit types de données primitifs de Java. Il contient une seule valeur non signée sur 16 bits — une unité de code UTF-16. Pour la plupart des scripts latins, cyrilliques, grecs, arabes, CJK et bien d'autres, cela correspond à l'intégralité du caractère. Pour les emoji et certains scripts moins courants, un caractère perçu par l'utilisateur nécessite deux chars (une paire de substitution).

Cette page explique comment écrire des littéraux char, le fait qu'un char est en réalité un petit entier, la classe wrapper Character pour la classification Unicode, le problème des paires de substitution, et les tableaux char[]. Une fois à l'aise avec les caractères individuels, la classe String s'appuie sur eux.

Littéraux char

Un littéral de caractère est un seul caractère entouré de guillemets simples :

char a = 'A';
char z = 'z';
char digit = '7';
char punct = '!';

Vous pouvez également utiliser des séquences d'échappement et des échappements Unicode :

char newline = '\n';
char tab = '\t';
char quote = '\'';
char back = '\\';
char copy = '©';   // ©
char pi = 'π';     // π

char est un entier sur 16 bits

Une valeur char est, en interne, un entier non signé sur 16 bits. Vous pouvez effectuer des opérations arithmétiques dessus et la convertir vers/depuis int :

char c = 'A';
int code = c;             // 65 — implicit widening to int
char next = (char) (c + 1); // 'B'
char digit5 = (char) ('0' + 5); // '5'

L'astuce classique pour tester les plages de caractères :

boolean isUpper = c >= 'A' && c <= 'Z';
boolean isDigit = c >= '0' && c <= '9';

Le wrapper Character

Character est la classe wrapper. Elle dispose de dizaines de méthodes utilitaires statiques pour classifier et convertir des caractères — plus fiables que le style c >= '0' ci-dessus car elles prennent en charge Unicode :

Character.isLetter('A');         // true
Character.isDigit('7');          // true
Character.isLetterOrDigit('é');  // true
Character.isWhitespace(' ');     // true
Character.isUpperCase('A');      // true
Character.isLowerCase('a');      // true
Character.toUpperCase('a');      // 'A'
Character.toLowerCase('A');      // 'a'
Character.getNumericValue('7');  // 7
Character.toString('A');         // "A"

Préférez les méthodes de Character aux vérifications manuelles de plages lorsque vous risquez de rencontrer du texte non ASCII.

Un char est une unité de code UTF-16, pas toujours un caractère utilisateur

C'est la partie subtile. Les chaînes Java sont en UTF-16. Pour les caractères dont les points de code vont jusqu'à U+FFFF (le Plan Multilingue de Base — la plupart des langues, la plupart des signes de ponctuation), un point de code tient dans un seul char. Pour les caractères au-delà de U+FFFF — la plupart des emoji, les scripts anciens et certains symboles musicaux — deux chars sont nécessaires (une paire de substitution).

String emoji = "🎉";
System.out.println(emoji.length());           // 2 — surrogate pair
System.out.println(emoji.codePointCount(0, 2)); // 1 — one user character

Si votre code traite du texte fourni par l'utilisateur et peut rencontrer des emoji ou des scripts rares, préférez les méthodes prenant en compte les points de code (String.codePoints(), Character.toString(int), Character.isLetter(int)) aux méthodes basées sur char.

char[] — tableaux de caractères

Un char[] est parfois utilisé pour le traitement de texte sensible aux performances ou pour les mots de passe (vous pouvez effacer le tableau après utilisation, alors que vous ne pouvez pas effacer une String immuable) :

char[] greeting = {'H', 'e', 'l', 'l', 'o'};
String s = new String(greeting);     // "Hello"

char[] back = s.toCharArray();

Une démonstration

Et ensuite

La classe Math Java — la bibliothèque de méthodes statiques pour l'arithmétique qui va au-delà de +, -, *, /.

Pratique