FAQ Langage JavaConsultez toutes les FAQ

Le type char de Java est un type primitif, codé sur 16 bits, qui contient la valeur Unicode du caractère. Le type objet wrapper du type primitif char est la classe java.lang.Character.

Une valeur de type char peut se déclarer de plusieurs manières. Prenons par exemple le caractère a (lettre A minuscule) :

char a = 'a';

char a = 97; // Valeur Unicode du caractère 'a'

char a = '\u0061'; // Valeur Unicode du caractère 'a' en hexadécimal.

1
2
3
4
5
char tab = '\t'; 
char lineFeed = '\n'; 
char returnCariage = '\r'; 
char quote = '\''; // Permet d’écrire ' 
char aslash = '\\'; // Permet d’écrire \

Oui, le type char est également un nombre : char est un entier non signé qui peut contenir des valeurs de [0-65535]. Toutes les opérations et comparaisons arithmétiques sont légales sur ce type.

Attention cependant, ces opérations et comparaisons portent sur la valeur Unicode du symbole, c'est-à-dire sur son index dans la table des symboles Unicode UTF-16. De plus, les opérations arithmétiques produisent des int (entier 32 bits ou mot) et non pas des char.

Ainsi, il est tout à fait possible de faire :

1
2
3
char a = '4'; // La valeur Unicode de '4' est 52. 
char b = '2'; // La valeur Unicode de '2' est 50. 
int c = a + b; // c vaut 102, car est égal à 52 + 50.

1
2
3
char a = '4'; // La valeur Unicode de '4' est 52. 
char b = '2'; // La valeur Unicode de '2' est 50. 
char d = (char) (a + b); // d vaut 'f' car la valeur Unicode de ce symbole est 102.

Le moyen le plus simple de déclarer une chaîne de caractères en Java est d’écrire du texte entre " (double-quote ou guillemets). Des suites de caractères écrites dans ce format sont automatiques interprétées comme étant de type java.lang.String. Les chaînes de caractères ainsi créées sont immuables (unmutable ou encore non-mutable en anglais), c'est-à-dire qu'on ne peut plus les modifier ultérieurement. De plus, et contrairement à d'autres langages de programmation, en Java, les chaînes de caractères ne sont pas terminées par le caractère null (le caractère à l'indice 0).

Par exemple :

String maChaine = "Salut le monde !"; // Chaîne de 16 caractères.

String maChaine = "S\u0061lut le monde !";  // Chaîne de 16 caractères également.

1
2
3
4
5
6
String tab = "\t"; // La chaîne fait 1 seul caractère. 
String lineFeed = "\n"; // Idem. 
String returnCariage = "\r"; // Idem. 
String quote = "\'"; // Idem. Permet d’écrire '  
String doubleQuote = "\""; // Idem. Permet d’écrire " 
String aslash = "\\"; // Idem. Permet d’écrire \

La manière la plus simple de passer de l'Unicode à l'ASCII est d'utiliser la classe java.lang.String.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
try { 
    String chaine = "Ma chaîne à traduire !"; 
  
    // Traduction en tableau de code ASCII : 
    byte[] bytes = chaine.getBytes("ASCII"); 
  
    // Affichage à l'écran : 
    for (int i=0; i<bytes.length; i++) { 
        System.out.println( bytes[i] ); 
    }  
} catch (java.io.UnsupportedEncodingException e) { 
    // Le codage n'est pas reconnu. 
    e.printStackTrace(); 
}

Pour connaitre le nombre de caractères d'une chaîne, il suffit d'utiliser la méthode length() de la classe String. Cette méthode renvoie le nombre de char utilisés pour représenter la chaîne.

Cependant, en Java, un char est codé sur 2 octets alors que les caractères Unicode peuvent avoir une taille variable selon l'encodage et l’alphabet utilisés (entre 1 et 4 octets). Ainsi la valeur renvoyée par la méthode length() reflète donc plutôt la taille occupée en mémoire et non pas le nombre de caractères Unicode de la chaîne (même si dans la majorité des cas le résultat sera le même).

Ainsi, afin de connaitre avec précision le nombre de caractères réels de la chaîne, il est nécessaire d'utiliser la méthode codePointCount() de la classe String, qui permet de renvoyer le nombre de caractères Unicode entre deux emplacements de la chaîne, quelle que soit leur taille en mémoire. Ainsi, pour connaitre le nombre de caractères effectif d'un String, il faut utiliser le code suivant :

1
2
String str = ... // la chaine 
int count = str.codePointCount(0, str.length());

1
2
3
4
5
6
String testString = "\uD800\uDF30"; // Un seul et unique caractère sera affiché. 
int charCount = testString.length(); 
int characterCount = testString.codePointCount(0, charCount); 
  
System.out.printf("char count: %d\n", charCount); 
System.out.printf("character count: %d\n", characterCount);

1
2
char count: 2 
character count: 1

Pour vérifier qu'une chaîne de caractères est vide, il suffit d'invoquer sa méthode isEmpty() ou de tester si la taille retournée par la méthode length() est égale à 0.

boolean empty = maChaine.isEmpty();

boolean empty = maChaine.length() == 0;

boolean empty = (maChaine == null) || maChaine.trim().isEmpty();

Les chaînes de caractères utilisent en interne un tableau de stockage de caractères (char[]). On notera également que les caractères de la chaîne sont indexés par des int.

En théorie, cela implique donc que la chaîne contient au maximum 2³¹-1 éléments, soit la valeur Integer.MAX_VALUE, le plus grand entier positif possible. La plus grande plage d'indices possible pour une chaîne est donc [0, 2³¹-2]. Cependant, il s'agit d'une limite théorique.

En pratique, dans les JVM récentes, il semble qu'il ne soit pas possible d'allouer un tableau dont la taille dépasse Integer.MAX_VALUE - 2. De plus chaque char fait 2 octets en mémoire, donc le poids effectif du tableau en mémoire est de deux fois sa longueur. Enfin, la classe String est un objet et non pas un primitif, donc chaque instance de cette classe porte avec elle un poids supplémentaire en mémoire en sus de celui du tableau de caractères.

Attention : si vous manipulez des chaînes (modification, concaténation, etc.) et à plus forte raison des chaînes de grande taille, vous devez utiliser des java.lang.StringBuffer, java.lang.StringBuilder ou des mécanismes similaires qui vous éviteront de créer des chaines intermédiaires sans prendre garde.

En Java, une instance de la classe String est dite immuable ou non-mutable, c'est-à-dire qu'après avoir été créée, la chaîne ne peut plus être modifiée. Cela s'avère très pratique dans beaucoup de situations : inutile par exemple de dupliquer une instance de String pour s'assurer qu'elle restera constante (comme c'est le cas en C++ par exemple). Mais cette propriété se révèle désastreuse avec l'emploi de l'opérateur + pour la concaténation de chaînes, car chaque étape de la concaténation implique la construction d'une nouvelle instance de String.

1
2
3
4
5
String resultat = ""; // Création d'une chaîne de caractères vide. 
for( int i=0; i<10; i++) { 
    resultat = resultat + i; 
}  
System.out.println(resultat); // "0123456789"

Comme nous venons de le voir, l'utilisation de l’opérateur + est déconseillée lorsque nous devons concaténer des chaînes de caractères entre elles. L'API Java offre plusieurs mécanismes permettant d'effectuer la concaténation de manière plus efficace : java.lang.StringBuilder, java.lang.StringBuffer, java.io.StringWriter, java.util.StringJoiner, java.util.Formatter, java.text.MessageFormat, etc.

StringBuilder et StringBuffer
Ces deux classes gèrent une chaîne modifiable. Elles ont a été spécialement conçues pour manipuler des chaînes de caractères et présentent toutes les deux des API compatibles.

• java.lang.StringBuffer - présente depuis Java 1.0, ses méthodes sont synchronisées et sont donc thread-safe. Elle peut donc être utilisée dans un environnement où plusieurs threads vont composer la chaîne de caractères ;
• java.lang.StringBuilder - présente depuis Java 1.5, ses méthodes ne sont pas synchronisées. Elle offre donc les meilleures performances, mais doit être utilisée dans un environnement mono-thread. Il s'agit de la classe que vous serez amené à utiliser le plus souvent.
  

1
2
3
4
5
StringBuilder sb = new StringBuilder(20); // 20 = une estimation de la taille maximale de notre chaîne. 
for (int i = 0 ; i < 10 ; i++) { 
    sb.append(i); 
}  
System.out.println(sb.toString()); // "0123456789"

1
2
3
4
  
StringJoiner sj = new StringJoiner(":", "[", "]"); 
sj.add("bouye").add("clement").add("mickael"); 
String maChaine = sj.toString(); // [bouye:clement:mickael]

String result = String.format("%s%s%s", "Salut", " ", "le monde !");

String result = MessageFormat.format("{0}{1}{2}", "Salut", " ", "le monde !");

Il arrive assez souvent qu'il soit nécessaire de concaténer des valeurs contenues dans un tableau, une collection ou accessibles par un itérateur dans une chaîne de caractères en utilisant un séparateur donné ; par exemple si vous devez écrire dans un fichier au format CSV ou encore lors de la construction des paramètres pour effectuer une requête SQL ou sur un site web. Il existe plusieurs manières de procéder à une telle construction :

Boucle for, while ou do-while
Cette manière classique de faire va itérer sur les valeurs contenues dans la source (ici un tableau) pour insérer le séparateur entre chaque valeur en prenant soin d’éviter de mettre un séparateur en fin de chaîne. Les valeurs sont insérées dans une instance de StringBuilder pour éviter de construire plein de petites chaînes intermédiaires.

1
2
3
4
5
6
7
8
9
10
String separateur = ","; 
int[] valeurs = { 0, 1, 2, 3, 4 }; 
StringBuilder tampon = new StringBuilder(); 
for (int index = 0 ; index < valeurs.length ; index++) { 
    tampon.append(valeurs[index]); 
    if (index != valeurs.length - 1) { 
        tampon.append(separateur); // Insertion du séparateur. 
    } 
} 
String chaine = tampon.toString();

1
2
3
4
5
6
7
8
9
String separateur = ","; 
int[] valeurs = { 0, 1, 2, 3, 4 }; 
StringBuilder tampon = new StringBuilder(); 
tampon.append(valeurs[0]); // Insertion de la première valeur. 
for (int index = 1 ; index < valeurs.length ; index++) { 
    tampon.append(separateur); // Insertion du séparateur. 
    tampon.append(valeurs[index]); 
} 
String chaine = tampon.toString();

1
2
3
4
5
6
7
8
String separateur = ","; 
int[] valeurs = { 0, 1, 2, 3, 4 }; 
StringBuilder tampon = new StringBuilder(); 
for (int valeur : valeurs) { 
    tampon.append(valeur); 
    tampon.append(separateur); // Insertion du séparateur. 
} 
String chaine = (tampon.length() == 0) ? "" : tampon.substring(0, tampon.length() - separateur.length()); // On enlève le dernier séparateur.

1
2
3
String separateur = ","; 
String[] valeurs = { "0", "1", "2", "3", "4" }; 
String chaine = String.join(separateur, valeurs);

1
2
3
4
5
String separateur = ","; 
int[] valeurs = { 0, 1, 2, 3, 4 }; 
String chaine = Arrays.stream(valeurs) 
    .mapToObject(String::valueOf) 
    .collect(Collectors.joining(separateur));

Opérateur ==
Avant d'essayer de comparer deux chaînes de caractères, il faut bien comprendre que l'opérateur == permet de comparer entre eux les types primitifs (int, float, boolean, etc. ) mais que, dans le cas des objets, cet opérateur compare les emplacements mémoire des objets. Deux instances d'une classe, même initialisées avec les mêmes paramètres, occupent des espaces mémoire différents, elles sont donc différentes du point de vue de l’opérateur ==.

De manière générale, il ne faut donc pas utiliser cet opérateur pour comparer deux chaînes de caractères entre elles !

La méthode equals()
L'opération qui permet de comparer les objets entre eux est la méthode equals() de la classe java.lang.Object.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
String a = "coucou"; 
String b = "coucou"; 
String c = "bonjour"; 
String d = c; 
  
boolean test1 = a == b; 
/**  
 * FAUX, a et b sont des instances différentes de String. 
 * Ce résultat est théorique, car certains compilateurs pourraient optimiser 
 * le code pour ne créer qu'une seule instance mémoire. 
 */ 
  
boolean test2 = a.equals(b); // VRAI, equals() compare les chaînes caractère par caractère. 
  
c == d; // VRAI, c et d représentent la même instance mémoire de String

boolean test = Objects.equals(a, b);

1
2
3
4
5
6
String a = "coucou"; // 1re instance.  
String b = "coucou"; // 2e instance.  
a = a.intern(); // l'instance 1 est ajoutée à la liste, 'a' ne change pas de valeur.  
b = b.intern(); // Équivalent à : b = a;  
  
a == b; // VRAI.

• compareTo() - cette méthode fait une comparaison lexicographique entre la chaîne actuelle et une seconde chaîne passée en paramètre. Elle retourne 0 si les deux chaînes sont identiques, un nombre positif si la chaîne actuelle est « plus grande » que le paramètre ou un nombre négatif si la chaîne actuelle est « plus petite » que le paramètre.
  

  Code Java :

  Sélectionner tout

  int result = "toto".compareTo("tutu");

• compareToIgnoreCase() - la comparaison s'effectue de manière lexicographique, mais le résultat de cette méthode ignore la casse (majuscules/minuscules) des deux chaînes.
  
  

  Code Java :

  Sélectionner tout

  int result = "toto".compareToIgnoreCase("Toto"); // Retourne 0.

  
  Ce code est en fait équivalent au code suivant :
  
  

  Code Java :

  Sélectionner tout

  int result = "toto".toUpperCase().compareTo("Toto".toUpperCase());  // Retourne 0.

  
  Qui est lui-même équivalent à :
  
  

  Code Java :

  Sélectionner tout

  int result = "TOTO".compareTo("TOTO");  // Retourne 0.

Par défaut, toutes les opérations de comparaison et égalité des chaînes de caractères se basent sur leurs valeurs Unicode. Cela permet des traitements très rapides, car il s'agit d'une comparaison bit à bit, mais cela produit des résultats non souhaitables avec certaines locales...

Prenons par exemple le code suivant qui permet de trier une liste et de l'afficher :

1
2
3
4
5
6
7
List<String> list = new ArrayList<String>(); 
list.add("oxygène"); 
list.add("où"); 
list.add("ou"); 
Collections.sort(list); 
  
System.out.println(list);

[ou, oxygène, où]

Collections.sort(list, Collator.getInstance(Locale.FRANCE));

• Collator.IDENTICAL - les caractères doivent être strictement identiques ;
• Collator.TERTIARY - diminue les contraintes de IDENTICAL en ignorant les différences sur les caractères de contrôle (ex. : \u0001 == \u0002) ;
• Collator.SECONDARY - diminue les contraintes de TERTIARY en ignorant les différences de casse minuscules/majuscules (ex. : 'a' == 'A') ;
• Collator.PRIMARY - diminue les contraintes de TERTIARY en ignorant les accents (ex. : 'a' == 'à' == 'â' == 'ä' == 'A' == 'Ä' etc.).
  

Selon votre version de Java et vos besoins, il y a plusieurs solutions possibles à cet épineux problème.

La classe Normalizer
Avec Java 6, il est possible d'utiliser la classe java.text.Normalizer afin de décomposer le codage Unicode des accents en deux « caractères » :

• le premier caractère correspond à la lettre sans aucune accentuation ;
• le second caractère est un « diacritique », c'est-à-dire un signe qui s'ajoute au caractère auquel il est associé.
  

1
2
3
4
public static String sansAccents(String source) { 
    String normalized = Normalizer.normalize(source, Normalizer.Form.NFD); 
    return normalized.replaceAll("[\u0300-\u036F]", ""); 
}

1
2
3
4
5
public static String sansAccents(String source) { 
    final String normalized = Normalizer.normalize(source, Normalizer.Form.NFD); 
    final Pattern pattern = Pattern.compile("\\p{InCombiningDiacriticalMarks}+"); 
    return pattern.matcher(normalized).replaceAll(""); 
}

1
2
3
4
public static String sansAccents(String s) { 
    Transliterator accentsconverter = Transliterator.getInstance("NFD; [:M:] Remove; NFC; "); 
    return accentsconverter.transliterate(s); 
}

Pour faire cela, on peut utiliser le constructeur de String prenant en paramètre un tableau de byte ainsi que l'encodage à utiliser.

Voici un exemple permettant de convertir une chaîne codée en UTF-8 en ISO-8859-1 (Latin 1, français) :

1
2
byte[] bytesUTF8 = ... ;  
byte[] bytesISO = new String(bytesUTF8, "ISO-8859-1").getBytes();

Il existe bien des manières de convertir des objets quelconques en chaine de caractères, par exemple, en utilisant des classes de conversion ou de formatage destinées à des usages très particuliers et spécialisés (ex. : formatage des nombres, durées, temps, dates ou monnaies en fonction de la langue, conversion en XML, etc.). C'est pourquoi nous allons uniquement aborder ici les méthodes les plus simples pour procéder à une telle conversion.

Méthode toString()
Il s'agit de la méthode la plus simple pour convertir un objet quelconque en chaine de caractères : la classe java.lang.Object définit la méthode publique toString() qui renvoie une représentation de l'objet sous forme de String. Donc il est possible d'invoquer cette méthode sur n'importe quel objet Java.

Dans l'API cette représentation peut varier beaucoup d'une classe à une autre. Il n'y a pas vraiment de règle préétablie et chaque cas est différent :

• par défaut, dans la classe Object, cette méthode renvoie l’équivalent de getClass().getName() + '@' + Integer.toHexString(hashCode()), par exemple : Voiture@7AC123 ;
• d'autres classes comme les collections, les couleurs ou encore les composants d'affichage Swing peuvent renvoyer une version formatée des valeurs qu'elles contiennent.
  Par exemple :
  
  

  Code Java :

  Sélectionner tout

  1
  2
  3
  4
  List<Integer> list = Arrays.asList(0, 1, 2, 3); 
  System.out.println(list); 
  JLabel label = new JLabel("toto"); 
  System.out.println(label);

  
  Ce qui affichera :
  
  

  Code Console :

  Sélectionner tout

  1
  2
  [0, 1, 2, 3] 
  javax.swing.JLabel[,0,0,0x0,invalid,alignmentX=0.0,alignmentY=0.0,border=,flags=8388608,[...]

1
2
3
4
5
6
7
8
9
10
11
12
public class Personne { 
    private String nom; 
    private String prenom; 
  
    [...] 
  
    @Override 
    public String toString() { 
        String resultat  = prenom + " " + nom; 
        return resultat; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
public class Personne { 
    private String nom; 
    private String prenom; 
  
    [...] 
  
    @Override 
    public String toString() { 
        StringBuilder resultat = new StringBuilder().append(prenom).append(" ").append(nom); 
        return resultat.toString(); 
    } 
}

1
2
3
4
Personne personne = [...] 
System.out.println(personne.toString()); 
// Ou 
System.out.println(personne); // La méthode toString() sera invoquée de manière implicite. La chaine "null" sera affichée si personne est nulle.

Jean Durant

String chaine = personne.toString(); // Peut provoquer une NullPointerException si personne est nulle.

String chaine = Objects.toString(personne); // Renvoie "null" si personne est nulle.

String chaine = Objects.toString(personne, "Pas de valeur"); // Renvoie "Pas de valeur" si personne est nulle.

JDK 1.0 :
Il faut utiliser un objet java.util.StringTokenizer qui permet aisément de découper une chaîne en sous-chaînes séparées par des délimiteurs que l'on peut préciser.

1
2
3
4
5
String maChaine = "Salut le monde !";    
final StringTokenizer tokenizer = new StringTokenizer(maChaine, " "); 
while (tokenizer.hasMoreTokens()) { 
    System.out.println(tokenizer.nextToken()); 
}

1
2
3
4
5
String maChaine = "Salut le monde !";    
String[] tokens = maChaine.split("\\s+"); 
for (String token : tokens) { 
    System.out.println(token); 
}