Méthodes de String en Java

La classe String dispose de dizaines de méthodes. Ce chapitre est une référence pratique de celles que vous utiliserez réellement, regroupées par usage : inspection, comparaison, recherche, découpage, transformation, division/jointure, conversion et formatage.

Rappel : les chaînes sont immuables. Chaque méthode ci-dessous renvoie une nouvelle chaîne (ou une autre valeur) — elle ne modifie jamais la chaîne sur laquelle vous l'avez appelée. Cela signifie qu'un appel tel que s.toUpperCase(); seul ne sert à rien ; vous devez capturer le résultat :

String s = "hello";
s.toUpperCase();        // result discarded — s is still "hello"
s = s.toUpperCase();    // s is now "HELLO"

Les index sont basés sur zéro et comptent les unités de code UTF-16, et non les caractères perçus par l'utilisateur, ce qui importe pour les emoji et autres caractères supplémentaires.

Inspecter une chaîne

"hello".length();      // 5
"".isEmpty();          // true
"   ".isBlank();       // true
"hello".charAt(1);     // 'e'

Comparer des chaînes

"hi".equals("hi");                  // true
"HI".equalsIgnoreCase("hi");        // true
"apple".compareTo("banana");        // negative

Préférez toujours .equals() à == pour comparer des contenus (Opérateurs de comparaison). == compare les références d'objets — si deux variables pointent vers le même objet — et non les caractères qu'ils contiennent. Parce que Java interne les littéraux de chaîne, == semble parfois fonctionner, puis échoue dès qu'une chaîne est construite à l'exécution :

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

a == b;          // true  — both point to the same interned literal
a == c;          // false — c is a different object
a.equals(c);     // true  — same contents

compareTo est ce qu'il vous faut pour le tri : il renvoie un nombre négatif, zéro ou un nombre positif, ce qui s'intègre directement dans Collections.sort ou les chaînes de Comparator.

Rechercher

String s = "abc-xyz-abc";
s.contains("xyz");       // true
s.indexOf("abc");        // 0
s.lastIndexOf("abc");    // 8
s.startsWith("abc");     // true
s.endsWith("xyz");       // false

Découper

String s = "Hello, World!";
s.substring(7);        // "World!"
s.substring(7, 12);    // "World"

Les index négatifs ne sont pas autorisés — ils lèvent une StringIndexOutOfBoundsException.

Transformer

"  hello  ".strip();                 // "hello"
"banana".replace("a", "_");          // "b_n_n_"
"hello".repeat(3);                   // "hellohellohello"
"abc 123".replaceAll("\\d", "*");    // "abc ***"

Diviser et joindre

"a,b,c".split(",");                     // ["a","b","c"]
String.join("-", "a", "b", "c");        // "a-b-c"
String.join(",", List.of("a","b"));     // "a,b"
"line1\nline2\nline3".lines().count();  // 3

split prend une regex, pas une chaîne simple — pensez donc à échapper les métacaractères regex : utilisez split("\\.") pour diviser sur un point littéral, et non split(".") (qui correspond à chaque caractère et renvoie un tableau vide). Les chaînes vides finales sont supprimées par défaut ; passez une limit négative (ex. split(",", -1)) pour les conserver.

Conversion

String.valueOf(42);              // "42"
Integer.parseInt("42");          // 42
Double.parseDouble("3.14");      // 3.14
"hello".toCharArray();           // {'h','e','l','l','o'}

Les méthodes parse* lèvent une NumberFormatException si le texte n'est pas un nombre valide, alors encapsulez les saisies utilisateur dans un try/catch ou validez-les d'abord. Contrairement à parseInt, String.valueOf(null) est sûre — elle renvoie la chaîne "null" plutôt que de lever une exception.

Formatage

String.format("%s is %d", "Ada", 36);     // "Ada is 36"
"%s is %d".formatted("Ada", 36);          // "Ada is 36"

Démonstration combinée

Prochaine étape

Concaténation de chaînes Java approfondit +, concat et StringBuilder, en expliquant quand chacun est l'outil approprié.

Pratique