Les chaînes en Java : créer, concaténer et utiliser les méthodes de String

Ce qu'est une chaîne (String)

Une String contient une séquence de caractères - du texte comme un nom, une phrase ou une ligne lue dans un fichier. Vous avez vu String listée parmi les types par référence à la page précédente ; ici, vous allez réellement en manipuler une. On écrit un littéral de chaîne avec des guillemets doubles (les guillemets simples sont réservés à un seul char) :

public class Main {
    public static void main(String[] args) {
        String greeting = "Hello, world";
        String empty = "";
        String name = "Ada";

        System.out.println(greeting);
        System.out.println("Name has " + name.length() + " characters");
    }
}

name.length() renvoie le nombre de caractères - 3 pour "Ada". C'est un appel de méthode, il faut donc les parenthèses.

Assembler des chaînes

L'opérateur + colle les chaînes les unes aux autres. Si l'un des côtés de + est une chaîne, l'autre côté est converti en texte automatiquement, ce qui vous permet de mélanger des nombres et des booléens sans aucun travail supplémentaire :

public class Main {
    public static void main(String[] args) {
        String first = "Ada";
        String last = "Lovelace";

        String full = first + " " + last;
        System.out.println(full);

        int age = 36;
        System.out.println(full + " is " + age + " years old");
    }
}

Un piège : comme + s'évalue de gauche à droite, "" + 1 + 2 produit "12" (chaîne + int, puis chaîne + int), mais 1 + 2 + "" produit "3" (les deux entiers s'additionnent d'abord, puis deviennent du texte). En cas de doute, entourez l'arithmétique de parenthèses.

Les chaînes sont immuables

C'est la chose la plus importante à comprendre sur les chaînes en Java : une String ne change jamais après sa création. Chaque méthode qui « modifie » une chaîne renvoie en réalité une toute nouvelle chaîne et laisse l'originale intacte. Donc si vous oubliez de récupérer la valeur de retour, rien ne se passe :

public class Main {
    public static void main(String[] args) {
        String s = "hello";

        s.toUpperCase();              // résultat jeté - bug !
        System.out.println(s);        // toujours "hello"

        s = s.toUpperCase();          // récupère la nouvelle chaîne
        System.out.println(s);        // maintenant "HELLO"
    }
}

Le premier appel calcule "HELLO" et le jette immédiatement. Seule la deuxième ligne, qui réaffecte dans s, a un effet visible. Presque tout le monde tombe une fois dans ce piège.

Comparer des chaînes

Utilisez .equals() pour comparer le contenu de deux chaînes. Recourir à == est l'erreur classique du débutant : == demande « est-ce le même objet en mémoire ? », et non « contiennent-elles le même texte ? » :

public class Main {
    public static void main(String[] args) {
        String a = "code";
        String b = new String("code");

        System.out.println(a == b);            // false - different objects
        System.out.println(a.equals(b));       // true  - same characters

        System.out.println("Hi".equalsIgnoreCase("hi"));  // true
    }
}

a == b vaut false ici parce que new String(...) force un objet distinct. Comparez toujours les valeurs de chaînes avec .equals() (ou .equalsIgnoreCase() pour ignorer la casse). Une astuce pratique pour éviter un plantage quand un côté peut être null est d'appeler .equals sur le littéral : "yes".equals(input) ne lève jamais d'exception, même si input vaut null.

Les méthodes de String du quotidien

Comme les chaînes sont immuables, chacune de ces méthodes renvoie une nouvelle chaîne (ou une valeur) au lieu de modifier l'originale. Voici celles que vous utiliserez constamment :

public class Main {
    public static void main(String[] args) {
        String s = "  Coddy Java  ";

        System.out.println(s.trim());              // "Coddy Java"
        System.out.println(s.trim().toUpperCase()); // "CODDY JAVA"
        System.out.println(s.contains("Java"));    // true
        System.out.println(s.indexOf("Java"));     // 8
        System.out.println("Coddy".charAt(0));     // 'C'
        System.out.println("a,b,c".split(",").length); // 3
        System.out.println("hello".replace("l", "L")); // "heLLo"
    }
}

Remarquez le chaînage : s.trim().toUpperCase() fonctionne parce que trim() renvoie une chaîne, sur laquelle vous appelez ensuite toUpperCase(). substring est une autre méthode incontournable - elle prend un indice de début (inclus) et un indice de fin facultatif (exclu) :

public class Main {
    public static void main(String[] args) {
        String date = "2026-06-04";

        System.out.println(date.substring(0, 4));  // "2026"
        System.out.println(date.substring(5));     // "06-04"
    }
}

Les indices commencent à zéro, donc substring(0, 4) récupère les caractères 0 à 3. Demander un indice au-delà de la fin lève une StringIndexOutOfBoundsException.

Construire des chaînes dans une boucle

Concaténer avec + convient pour quelques morceaux, mais le faire dans une grande boucle est lent - chaque + crée une nouvelle chaîne et recopie tout. Quand vous assemblez du texte dans une boucle, utilisez StringBuilder, qui modifie un tampon sur place et produit la chaîne finale en une seule fois à la fin :

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        String result = sb.toString().trim();
        System.out.println(result);   // "1 2 3 4 5"
    }
}

append renvoie le même builder, si bien que les appels s'enchaînent. Appelez .toString() pour obtenir une String ordinaire à la fin. Pour des assemblages ponctuels, restez sur + ; pour accumuler de nombreux morceaux, StringBuilder est le bon outil.

Suite : Le formatage de chaînes

La concaténation devient vite confuse dès qu'il faut des colonnes alignées, un nombre fixe de décimales ou des nombres complétés (padding). String.format et printf en Java utilisent un modèle avec des marqueurs % pour gérer tout cela proprement - c'est le sujet de la page suivante.