Les chaînes de caractères en Java

Un String représente une séquence de caractères et est, après int, le type que vous utiliserez le plus. C'est une classe (pas un type primitif), mais Java lui offre une syntaxe spéciale — des littéraux entre guillemets doubles, l'opérateur + pour la concaténation — ce qui lui donne une apparence de type primitif. Le fait le plus important à retenir sur les chaînes : elles sont immuables.

Ce chapitre explique comment créer des chaînes, pourquoi l'immuabilité est importante, comment mesurer et indexer des chaînes, comment les comparer correctement, les méthodes courantes, la concaténation, les blocs de texte multi-lignes et le formatage.

Créer une chaîne

La manière la plus simple est d'utiliser un littéral de chaîne entre guillemets doubles :

String greeting = "Hello, World!";
String empty = "";
String multi = "Line 1\nLine 2";   // \n is a newline

Vous pouvez également en construire une avec new, bien qu'il soit rarement nécessaire de le faire :

String fromLiteral = "Hello";
String fromNew = new String("Hello");

new String(...) alloue toujours un nouvel objet. Les littéraux sont mis en pool — deux littéraux ayant les mêmes caractères sont le même objet. Cela a de l'importance pour les comparaisons avec ==, mais pas vraiment pour le reste ; vous devriez toujours utiliser .equals() pour comparer le contenu.

Les chaînes sont immuables

Une fois qu'un String est créé, son contenu ne change jamais. Chaque méthode qui « modifie » une chaîne renvoie en réalité une nouvelle chaîne :

String s = "hello";
s.toUpperCase();
System.out.println(s);   // "hello" — unchanged

s = s.toUpperCase();
System.out.println(s);   // "HELLO" — new string assigned

L'immuabilité présente plusieurs avantages :

• Sûre à partager entre les threads — aucune synchronisation nécessaire.
• Le code de hachage peut être mis en cache.
• Les chaînes peuvent être utilisées sans risque comme clés de map.

La contrepartie : construire une longue chaîne dans une boucle avec + crée de nombreuses chaînes intermédiaires. Pour cela, utilisez StringBuilder (Concaténation de chaînes).

Longueur et indexation

length() retourne le nombre de caractères :

String s = "hello";
System.out.println(s.length());   // 5

charAt(i) retourne le caractère à l'index i (base zéro) :

System.out.println(s.charAt(0));   // 'h'
System.out.println(s.charAt(4));   // 'o'
// s.charAt(5);  // StringIndexOutOfBoundsException

Remarque : length() est le nombre d'unités de code UTF-16, pas toujours le nombre de caractères perçus par l'utilisateur. Pour la plupart des textes ASCII et BMP, c'est la même chose, mais les emoji et certains scripts non-latins utilisent des paires de substitution et comptent pour 2.

Comparer des chaînes

Utilisez .equals() pour l'égalité de contenu, jamais == :

String a = new String("hi");
String b = new String("hi");

System.out.println(a == b);         // false
System.out.println(a.equals(b));    // true

equalsIgnoreCase ignore la casse :

"HELLO".equalsIgnoreCase("hello");  // true

Pour le tri, utilisez compareTo. Il compare les chaînes lexicographiquement (par code de caractère) et retourne un nombre négatif quand la première chaîne est triée avant la seconde, 0 quand elles sont égales, et un nombre positif quand elle est triée après :

"apple".compareTo("banana");        // negative (a < b)
"apple".compareTo("apple");         // 0  — equal
"banana".compareTo("apple");        // positive (b > a)

Comme la comparaison se fait par code de caractère, les lettres majuscules (A–Z, codes 65–90) sont triées avant les minuscules (a–z, codes 97–122). Utilisez compareToIgnoreCase pour un tri insensible à la casse.

Opérations courantes

Les méthodes les plus utilisées, avec des exemples :

String s = "  Hello, World!  ";

s.length();                  // 17
s.trim();                    // "Hello, World!" (whitespace removed)
s.strip();                   // "Hello, World!" (Unicode-aware, Java 11+)
s.toUpperCase();             // "  HELLO, WORLD!  "
s.toLowerCase();             // "  hello, world!  "
s.contains("World");         // true
s.startsWith("  Hello");     // true
s.endsWith("!  ");           // true
s.indexOf("World");          // 9
s.indexOf("xyz");            // -1
s.replace(",", ";");         // "  Hello; World!  "
s.substring(2, 7);           // "Hello"
s.split(", ");               // ["  Hello", "World!  "]
s.isEmpty();                 // false  — length() == 0?
s.isBlank();                 // false  — only whitespace? (Java 11+)

Pour la référence complète, voir Méthodes String Java.

Concaténation

L'opérateur + joint des chaînes et convertit les autres types en chaîne si nécessaire :

String name = "Ada";
int age = 36;
String msg = "Name: " + name + ", Age: " + age;
// "Name: Ada, Age: 36"

Dans une boucle, préférez StringBuilder :

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++) {
    sb.append(i).append(",");
}
String result = sb.toString();

Blocs de texte — chaînes multi-lignes

Depuis Java 15, les blocs de texte vous permettent d'écrire des chaînes multi-lignes sans séquences d'échappement :

String json = """
        {
          "name": "Ada",
          "age": 36
        }
        """;

Le compilateur supprime l'espace blanc de début commun de chaque ligne, de sorte que votre indentation dans le source ne se retrouve pas dans la chaîne.

Formatage

String.format construit une chaîne avec des espaces réservés de style printf :

String s = String.format("Name: %s, Age: %d", "Ada", 36);

Les espaces réservés sont les mêmes que pour System.out.printf — voir Sortie Java.

Une démonstration

Et ensuite

Méthodes String Java — une référence de toutes les méthodes que vous utiliserez régulièrement.

Pratique