Listes, tableaux et chaînes de caractères en Java

Une ArrayList stocke des valeurs dans l’ordre. Elle grandit quand tu ajoutes un élément et rétrécit quand tu en supprimes un. Chaque élément possède un indice, à partir de 0. Importe la classe avant de l’utiliser : import java.util.ArrayList;.

Crée une liste dont le type est précisé

ArrayList<String> drinks = new ArrayList<>();
drinks.add("tea");
drinks.add("milk");

Le type indiqué entre les chevrons dans <String> précise ce que la liste stocke. Le diamant <> à droite permet à Java de déduire ce même type. La liste est d’abord vide, de taille 0 ; après ces deux appels, elle contient [tea, milk] et sa taille est 2. Afficher directement la liste montre ses éléments : System.out.println(drinks);.

Le type des éléments d’une liste doit être un type de classe. Pour les nombres, utilise une classe enveloppe : Integer pour int, Double pour double, Boolean pour boolean ou Character pour char. ArrayList<int> ne compile pas. Avec ArrayList<Integer> numbers = new ArrayList<>();, numbers.add(5) fonctionne car Java convertit automatiquement l’int en Integer. Le lire dans int n = numbers.get(0); effectue la conversion inverse.

Suis chaque changement d’indice

String old = drinks.set(0, "coffee");
drinks.add(1, "water");
String last = drinks.get(2);

set(0, "coffee") remplace le premier élément et renvoie l’ancienne valeur, donc old vaut "tea". La taille reste 2. L’insertion de "water" à l’indice 1 décale "milk" vers la droite. La liste est maintenant [coffee, water, milk] ; last vaut "milk" et la taille est 3.

L’indice supplémentaire autorisé pour l’insertion correspond à la position juste après le dernier élément actuel. Dans cette liste, add(3, "juice") ajoute l’élément à la fin, mais get(3) échouerait avant cette insertion. Un indice invalide provoque une IndexOutOfBoundsException. Utilise get(size() - 1) pour le dernier élément, après avoir vérifié que la liste n’est pas vide.

Commence avec des données ou collecte des saisies

Avec import java.util.List;, new ArrayList<>(List.of("red", "green", "blue")) crée une liste modifiable contenant ces valeurs. List.of(...) seul crée une liste non modifiable : add, set et remove provoquent une UnsupportedOperationException. Tu verras aussi List<String> names = new ArrayList<>(); ; la variable de type général List prend toujours en charge ces méthodes de liste.

Pour collecter des lignes jusqu’à une ligne vide, utilise un Scanner nommé scanner et une liste vide nommée lines :

while (true) {
    String line = scanner.nextLine();
    if (line.isEmpty()) {
        break;
    }
    lines.add(line);
}

La ligne qui arrête la saisie est vérifiée avant l’ajout : elle n’est donc pas stockée. lines.size() compte les lignes stockées. lines.isEmpty() vérifie s’il n’y en a aucune, et lines.clear() les supprime toutes quand tu dois réutiliser la liste.

Supprimer un élément modifie à la fois la taille et les indices des éléments suivants. Une recherche t’indique si une valeur existe ou où elle se trouve maintenant. Distingue bien une valeur de sa position, surtout dans une liste d’entiers.

Deux sens de remove

Pour [coffee, water, milk], remove(0) renvoie "coffee" et laisse [water, milk]. L’ancien indice 2 de "milk" est maintenant invalide ; cette valeur est passée à l’indice 1. Un indice enregistré n’est utile que tant que les modifications n’ont pas changé les positions qu’il décrit.

Supprimer par valeur ne signifie pas supprimer toutes les correspondances. En partant de [a, b, a], remove("a") laisse [b, a]. Un deuxième appel supprime le "a" restant. Supprimer une valeur absente renvoie false et laisse la liste inchangée ; tu peux donc utiliser directement le résultat :

boolean removed = names.remove("Lena");
if (removed) {
    System.out.println("Name removed");
}

Le piège de la surcharge pour les entiers

Un argument int sélectionne la forme par indice, même lorsque la liste stocke des entiers :

ArrayList<Integer> numbers = new ArrayList<>(List.of(10, 20, 30));
int removed = numbers.remove(1);
boolean found = numbers.remove(Integer.valueOf(10));

Le premier appel supprime l’élément à l’indice 1, donc removed vaut 20 et la liste devient [10, 30]. Le deuxième appel fournit explicitement un objet Integer. Il supprime la valeur 10, donne à found la valeur true et laisse [30]. Appeler remove(10) sur la liste d’origine de trois éléments essaierait d’accéder à l’indice 10 et provoquerait une IndexOutOfBoundsException.

Choisis un résultat de recherche

Pour colors = [red, green, blue, green], contains("green") vaut true, indexOf("green") vaut 1 et lastIndexOf("green") vaut 3. contains donne une réponse par oui ou non. Les deux méthodes qui renvoient un indice donnent la première ou la dernière position correspondante. Une valeur absente produit respectivement false ou -1.

Ces méthodes utilisent equals pour comparer les éléments. Les contenus des chaînes doivent correspondre exactement, casse comprise : indexOf("Green") vaut -1 pour cette liste. Pour une recherche insensible à la casse, une boucle peut comparer chaque nom avec equalsIgnoreCase.

Une correspondance à l’indice 0 reste une correspondance. Le test indexOf(x) > 0 la manque. Si tu as besoin de la position, teste explicitement la valeur indiquant l’absence :

int index = colors.indexOf("red");
if (index != -1) {
    colors.remove(index);
}

Ici, la recherche renvoie 0, le test réussit et la suppression à l’indice 0 laisse [green, blue, green]. Pour éviter les noms en double, vérifie avant d’ajouter : if (!names.contains(name)) { names.add(name); }. Pour supprimer toutes les occurrences, tu peux répéter la suppression tant que contains vaut true ou utiliser une boucle inverse sûre. Une boucle qui avance et incrémente toujours après une suppression peut sauter un élément décalé.

Une variable de liste contient une référence à un objet. Elle ne contient pas tous les éléments dans la variable elle-même. Cela explique pourquoi modifier une liste par un nom peut affecter un autre nom, et pourquoi affecter une valeur à un paramètre a un effet différent de la modification de ses éléments.

Suis les références

ArrayList<String> original = new ArrayList<>(List.of("tea"));
ArrayList<String> alias = original;
ArrayList<String> copy = new ArrayList<>(original);
alias.add("milk");
copy.add("juice");

original et alias désignent une même liste. Après l’ajout par alias, les deux montrent [tea, milk]. La copie est une liste distincte, créée avant cet ajout : elle contient donc [tea, juice]. Deux noms pour un même objet sont des alias. L’affectation copie une référence ; le constructeur de copie crée une nouvelle liste et y copie les éléments.

La liste copiée contient des références aux mêmes objets éléments. Avec les chaînes et les valeurs enveloppées, ces objets éléments ne peuvent pas changer : remplacer une case dans une liste ne modifie donc pas la case de l’autre liste. Copier une liste suffit pour permettre aux deux listes d’ajouter, de supprimer et de remplacer des éléments indépendamment.

Une méthode reçoit une copie de la référence

Java transmet les arguments par valeur. Pour une liste, cette valeur est une référence. L’appelant et le paramètre désignent initialement la même liste :

static void addBonus(ArrayList<Integer> scores, int bonus) {
    for (int i = 0; i < scores.size(); i++) {
        scores.set(i, scores.get(i) + bonus);
    }
}

Appeler addBonus(scores, 5) sur [70, 85] transforme la liste de l’appelant en [75, 90]. La méthode n’a pas besoin de renvoyer une liste car elle modifie l’objet partagé. Mais l’affectation scores = new ArrayList<>(); dans la méthode ne redirige que son paramètre local. La variable de l’appelant désigne toujours l’ancienne liste.

Un paramètre int reçoit une copie du nombre. Modifier ce paramètre ne peut pas modifier la variable int de l’appelant. Dans les deux cas, le paramètre est local ; ce qui change, c’est que sa valeur désigne ou non un objet modifiable partagé.

Renvoie de nouvelles données lorsque c’est la tâche demandée

static ArrayList<String> longWords(ArrayList<String> words, int minLength) {
    ArrayList<String> result = new ArrayList<>();
    for (String word : words) {
        if (word.length() >= minLength) {
            result.add(word);
        }
    }
    return result;
}

La méthode lit words et écrit uniquement dans result, donc l’entrée reste inchangée. Une méthode qui modifie un argument doit indiquer ce comportement, comme le fait addBonus. Une méthode qui renvoie de nouvelles données facilite la vérification de la sortie séparément de l’entrée.

Compare les contenus et gère l’absence de résultat

a == b vérifie si deux références de liste désignent le même objet. a.equals(b) vérifie que les tailles sont égales et que les éléments sont égaux dans le même ordre. Deux listes [1, 2] construites séparément ont un contenu égal mais des identités différentes ; [2, 1] n’a pas le même contenu dans l’ordre de la liste.

Une liste vide est un véritable objet de taille 0. Une boucle qui la parcourt ne s’exécute aucune fois, mais get(0) échoue car il n’existe aucun indice d’élément. null signifie qu’il n’y a aucun objet liste ; même size() provoque alors une NullPointerException. Une méthode sans correspondance peut renvoyer une liste de résultat vide, ce qui permet à son appelant de parcourir normalement le résultat.

Un tableau stocke un nombre fixe d’éléments d’un même type. Tu choisis sa longueur à sa création. Les éléments peuvent changer, mais pas le nombre de cases de ce tableau. Les tableaux peuvent stocker directement des valeurs primitives.

Crée et remplis des cases

int[] scores = new int[5];
scores[0] = 90;
int first = scores[0];
int[] primes = {2, 3, 5, 7, 11};

new int[5] crée cinq cases. Leurs indices sont 0, 1, 2, 3 et 4. Les crochets permettent de lire et d’écrire une case, donc first prend la valeur 90. L’initialiseur de primes crée et remplit cinq cases à la fois. Lorsqu’un tableau rempli est nécessaire dans une expression, comme un argument de méthode, utilise new int[] {2, 3, 5}.

La longueur est un champ : scores.length, sans parenthèses. Elle compte toutes les cases, y compris celles auxquelles tu n’as pas affecté de valeur toi-même. Ajouter une valeur à la case 0 ne fait pas passer la longueur de 5 à 1.

Ces noms ne sont pas interchangeables. Un tableau n’a pas de méthode size(), et une chaîne nécessite des parenthèses après length.

Identifie les valeurs initiales

Les nouvelles cases d’un tableau reçoivent des valeurs par défaut. Les tableaux de types primitifs numériques commencent avec zéro : 0 pour int, 0,0 pour double. Un boolean[] commence avec false ; un char[] commence avec le caractère dont le code est zéro, écrit '\u0000'. Les tableaux de types de classe, dont String[], commencent avec des références null.

String[] words = new String[3];
words[0] = "sun";
System.out.println(words[0].length());

Ce code affiche 3 car la case 0 référence maintenant "sun". Les cases 1 et 2 contiennent encore null. Appeler words[1].length() provoque une NullPointerException : il n’y a pas encore de chaîne à cet endroit. Une case contenant null par défaut est différente d’une chaîne vide "", qui est un objet de longueur 0.

Lis la sortie et reste dans le tableau

Importe java.util.Arrays et utilise System.out.println(Arrays.toString(scores)); pour afficher [90, 0, 0, 0, 0]. Afficher directement scores montre un code de type et d’identité comme [I@1b6d3586, pas ses éléments. Le code d’identité ne constitue pas un compte rendu utile des nombres stockés.

Voici les températures d’une semaine en degrés Celsius :

double[] temps = {12.5, 14.0, 9.5, 11.0, 15.5, 13.0, 10.5};
temps[2] = 10.0;

La mesure du troisième jour passe de 9,5 à 10,0. La première mesure est temps[0] ; la dernière est temps[6], ou temps[temps.length - 1]. temps[7] est en dehors du tableau. Java provoque une ArrayIndexOutOfBoundsException pour un indice de tableau invalide. Dans une boucle à indice, utilise i < temps.length : i <= temps.length essaie d’accéder à une case supplémentaire après la dernière case valide. Un tableau de longueur nulle n’a aucun indice d’élément valide.

Une variable de tableau contient une référence, tout comme une variable de liste. Affecter cette référence crée un autre nom pour le même tableau. Une copie distincte nécessite un nouvel objet tableau, et comparer les contenus nécessite une méthode qui vérifie les cases.

Affectation et copie

int[] a = {4, 9, 2};
int[] alias = a;
int[] copy = Arrays.copyOf(a, a.length);
alias[0] = 99;

Maintenant, a et alias montrent tous deux [99, 9, 2] ; copy montre toujours [4, 9, 2]. Arrays.copyOf(a, a.length) crée un nouveau tableau de même longueur. a.clone() peut aussi le copier. Importe java.util.Arrays pour les méthodes utilitaires.

Demander une longueur différente modifie le nouveau tableau, pas l’ancien. Arrays.copyOf(new int[] {2, 3, 5}, 4) donne [2, 3, 5, 0]. Les cases supplémentaires reçoivent des valeurs par défaut. Pour qu’une variable référence un tableau plus grand, affecte-lui la copie renvoyée. Tout alias de l’original référence toujours l’ancien tableau.

Les appels de méthode partagent l’objet

static void doubleAll(int[] values) {
    for (int i = 0; i < values.length; i++) {
        values[i] = values[i] * 2;
    }
}

Le paramètre reçoit une copie de la référence. La méthode modifie donc les cases du tableau de l’appelant. Réaffecter values à un nouveau tableau ne modifierait que le paramètre. Une méthode peut aussi renvoyer un nouveau tableau : return new int[] {values[0], values[values.length - 1]}; produit [4, 2] pour l’entrée {4, 9, 2}. Cette expression nécessite une entrée non vide car elle lit deux indices.

L’égalité de contenu est différente pour les tableaux

Pour les tableaux créés séparément a = {1, 2} et b = {1, 2}, a == b et a.equals(b) valent tous deux false : equals pour les tableaux vérifie l’identité. Arrays.equals(a, b) vaut true car les éléments correspondants sont égaux. C’est différent pour une ArrayList, dont la méthode equals compare les contenus ordonnés.

Sauvegarde une valeur avant de l’écraser

Pour échanger deux positions, conserve une ancienne valeur dans une variable temporaire :

int temp = a[0];
a[0] = a[2];
a[2] = temp;

En partant de {4, 9, 2}, la première ligne sauvegarde 4. La deuxième produit [2, 9, 2]. La troisième rétablit le 4 sauvegardé à l’indice 2, ce qui donne [2, 9, 4]. Sans temp, affecter a[2] = a[0] après la deuxième ligne recopierait 2 et ferait perdre le 4 d’origine.

Choisis une structure adaptée aux données

Les tableaux apparaissent aussi dans main(String[] args) et comme résultat de String.split. Pour un String[] words, new ArrayList<>(Arrays.asList(words)) crée une liste qui peut grandir. Pour un int[], crée une ArrayList<Integer> et ajoute chaque entier dans une boucle. Arrays.asList appliqué au tableau primitif traite le tableau entier comme un seul élément : il ne crée donc pas une liste de ses nombres individuels.

Une boucle permet à un même morceau de code de traiter chaque élément. Le choix dépend de ce dont le corps de la boucle a besoin : seulement une valeur, sa position ou un moyen de modifier la collection. Les tableaux comme les ArrayList prennent en charge les boucles à indice et les boucles for-each.

Parcours les valeurs dans l’ordre

for (String task : tasks) {
    System.out.println(task);
}

Lis ceci comme « pour chaque tâche dans tasks ». Avec [shop, cook, clean], le code affiche les trois chaînes dans cet ordre. La variable de boucle a le type des éléments. Pour ArrayList<Integer>, utilise int pour convertir automatiquement chaque valeur enveloppée en valeur primitive ou Integer pour conserver la référence à l’objet enveloppe. Pour les caractères d’une chaîne, for (char c : word.toCharArray()) parcourt les valeurs char.

Une boucle for-each ne fournit pas d’indice. Si tu as besoin de lignes numérotées, utilise une boucle à indice :

for (int i = 0; i < tasks.size(); i++) {
    System.out.println((i + 1) + ". " + tasks.get(i));
}

L’indice commence à 0, mais le numéro de ligne affiché commence à 1. Les parenthèses font de i + 1 une addition avant que son résultat ne devienne une partie du texte. Pour un tableau, remplace la condition par i < tasks.length et lis tasks[i]. Une boucle while peut faire le même travail en initialisant un compteur avant la boucle et en l’incrémentant dans le corps.

Modifie une valeur par sa position

int[] nums = {4, 9, 2};
for (int n : nums) {
    n = n * 2;
}

Ce code laisse le tableau inchangé. Chaque passage place une copie d’une valeur primitive dans n ; affecter une valeur à cette variable locale ne modifie pas la case d’origine. Pour modifier le tableau :

for (int i = 0; i < nums.length; i++) {
    nums[i] = nums[i] * 2;
}

Le résultat est [8, 18, 4]. Pour une liste d’entiers, la mise à jour correspondante est list.set(i, list.get(i) * 2). L’indice indique à Java quel élément stocké remplacer.

Adapte les bornes au corps de la boucle

Pour parcourir une liste à l’envers, commence à tasks.size() - 1, continue tant que i >= 0 et utilise i--. Le parcours visite clean, cook, puis shop. Pour prendre un élément sur deux, tu peux utiliser i += 2 dans une boucle qui avance.

Les comparaisons avec un voisin nécessitent un intervalle plus court. Si le corps lit à la fois list.get(i) et list.get(i + 1), la condition est i < list.size() - 1. La dernière position de départ valide est l’avant-dernier élément. Utiliser la condition habituelle d’un parcours complet essaierait de lire un voisin inexistant après le dernier élément.

Lorsque tu traites ensemble deux listes de même longueur, utilise un indice pour accéder aux deux. Par exemple, names.get(i) et scores.get(i) désignent les entrées correspondantes. Une boucle for-each est plus simple lorsque la position ne joue aucun rôle, par exemple pour afficher chaque nom ou ajouter chaque valeur à une somme.

Commencer à 1 saute le premier élément sans avertissement. Utiliser <= size() ou <= length essaie d’accéder à un indice supplémentaire invalide. Une liste ou un tableau vide ne nécessite aucune règle particulière de parcours : la condition initiale est fausse, donc le corps ne s’exécute aucune fois. Tout code ultérieur qui divise par l’effectif ou lit un élément doit gérer lui-même ce cas vide.

Un accumulateur conserve un résultat construit au fil des passages dans une boucle. Initialise-le avant la boucle, mets-le à jour à l’intérieur, puis utilise-le après. La valeur initiale dépend de la tâche : une somme ou un effectif commence à 0, tandis qu’un maximum nécessite un élément réel.

Sommes et moyennes

int sum = 0;
for (int value : numbers) {
    sum += value;
}
if (!numbers.isEmpty()) {
    double average = (double) sum / numbers.size();
    System.out.println(average);
}

Pour [4, 7, 8], sum passe de 0 à 4, puis à 11 et enfin à 19. Les deux opérandes de sum / numbers.size() seraient des entiers, ce qui donnerait 6. Effectuer un transtypage de sum avant la division donne environ 6,33. Convertir le quotient déjà calculé ne ferait que transformer le 6 tronqué en 6,0.

Une collection vide n’a pas de moyenne ordinaire. La division entière par zéro provoque une ArithmeticException ; la division en virgule flottante 0.0 / 0 donne NaN. Décide de ce que signifie le cas vide pour le programme avant de diviser, par exemple afficher « Aucune mesure ». Pour les distances décimales [5.0, 7.5, 10.0] km, une somme de type double vaut 22,5 km et la moyenne est de 7,5 km.

Compte seulement les correspondances

Un comptage conditionnel commence à 0 et ne s’incrémente que lorsque son test réussit. Pour les températures {22, 27, 31, 24, 26} en degrés Celsius, if (t > 25) { count++; } donne 3. Place l’initialisation en dehors de la boucle ; remettre count à zéro à chaque passage ferait perdre les correspondances précédentes.

Trouve un extremum et sa position

Pour un tableau non vide, commence par int max = values[0];. Remplace max chaque fois qu’une valeur parcourue est plus grande. Commencer à 0 échoue pour {-5, -2, -9} : le résultat indiqué est 0 alors qu’aucun élément n’a cette valeur. Commencer par -5 permet à la boucle de trouver le bon maximum, -2. Un minimum utilise le même schéma avec <.

Quand la position compte, conserve le meilleur indice :

int best = 0;
for (int i = 1; i < numbers.size(); i++) {
    if (numbers.get(i) > numbers.get(best)) {
        best = i;
    }
}

Pour [4, 7, 8], best vaut 2 à la fin et numbers.get(best) vaut 8. La boucle commence à 1 car l’indice 0 est déjà le candidat initial. Avec >, une valeur égale ne remplace pas le candidat actuel, ce qui conserve le premier maximum. Avec >=, chaque égalité le remplace, ce qui conserve le dernier maximum. Vérifie que la collection n’est pas vide avant de créer un candidat à l’indice 0.

Collecte les valeurs correspondantes

Le filtrage utilise une liste de résultat vide comme accumulateur. Parcours chaque mot, ajoute-le lorsque word.length() > 4 et renvoie le résultat. Pour [sun, planet, moon, galaxy], le résultat est [planet, galaxy]. Lire l’entrée et ajouter les éléments à une liste distincte laisse l’entrée inchangée.

Pour deux éléments Integer, == compare l’identité des objets. Les petites valeurs mises en cache peuvent masquer cette erreur ; des valeurs plus grandes égales peuvent être des objets différents. Compare-les avec equals ou convertis-les d’abord en valeurs primitives dans des variables int. Les opérateurs numériques <, >, <= et >= convertissent les valeurs enveloppées en valeurs primitives : le code qui cherche le meilleur indice compare donc leurs nombres.

Une recherche linéaire vérifie les éléments les uns après les autres. Elle fonctionne quel que soit l’ordre des données. Une recherche de la première correspondance peut s’arrêter dès qu’elle la trouve ; une recherche infructueuse doit atteindre la fin avant de conclure qu’aucun élément ne correspond.

Renvoie le premier indice correspondant

static int indexOfName(ArrayList<String> names, String target) {
    for (int i = 0; i < names.size(); i++) {
        if (names.get(i).equals(target)) {
            return i;
        }
    }
    return -1;
}

Si le premier nom correspondant est à l’indice 2, la méthode vérifie les indices 0, 1 et 2, puis renvoie immédiatement 2. L’instruction return -1 est après la boucle car seul un parcours achevé établit l’absence de correspondance. Placer else { return -1; } à l’intérieur arrêterait la recherche au premier élément non correspondant et ignorerait tous les candidats suivants.

La valeur -1 indiquant l’absence ne peut pas être un indice valide. L’appelant doit la vérifier avant de lire le résultat :

int index = indexOfName(names, "Ahmed");
if (index != -1) {
    System.out.println(names.get(index));
}

Le test index > 0 manquerait une correspondance valide à l’indice 0. Utiliser directement -1 dans get provoquerait une exception. Sur une liste vide, le corps de la boucle ne s’exécute jamais et la méthode renvoie correctement -1.

Adapte la comparaison à la tâche

Pour rechercher des valeurs exactes dans une liste, contains et indexOf effectuent déjà une recherche linéaire. Écris une boucle pour un tableau ou une condition comme « commence par L ». Utilise equals ou equalsIgnoreCase pour les chaînes, == pour les valeurs primitives et equals pour deux objets Integer. Un test d’identité de chaînes peut manquer des textes égaux.

Pour String[] cities = {"Oslo", "Lima", "Lagos", "Pune"}, teste cities[i].startsWith("L"). Le test échoue à l’indice 0 et réussit à l’indice 1 : le résultat pour la première correspondance est donc 1. Si la tâche demande toutes les correspondances, ne renvoie pas encore de résultat. Ajoute les indices correspondants à une liste de résultat et termine le parcours ; cela donne [1, 2]. Pour compter les correspondances, incrémente un compteur au lieu de stocker les positions.

Choisis la forme de la réponse

Une recherche dont la réponse est oui ou non peut commencer par boolean found = false;. En cas de correspondance, donne-lui la valeur true et quitte la boucle avec break. Sans cette sortie, la réponse finale reste vraie mais le programme vérifie des valeurs dont il n’a plus besoin. Une méthode de recherche peut aussi renvoyer immédiatement true et renvoyer false après la boucle.

Renvoyer un élément nécessite un résultat distinct pour « rien trouvé ». Pour une String, il s’agit souvent de null ; l’appelant doit le vérifier avant d’appeler une méthode de String. Renvoyer un indice avec -1 rend le cas d’absence visible sans prétendre qu’une chaîne vide est une donnée absente.

Compte le travail réellement effectué par la recherche

Une valeur recherchée à la première position nécessite une comparaison. À la troisième position, elle en nécessite trois. Une valeur absente parmi 10 000 noms nécessite les 10 000 comparaisons. La première comparaison infructueuse ne permet pas d’établir que la valeur recherchée est absente des positions restantes. Une recherche de toutes les correspondances vérifie aussi chaque élément, même après une correspondance précoce, car des valeurs ultérieures peuvent également correspondre.

Supprimer des éléments d’une ArrayList modifie les positions que la boucle cherche à parcourir. La méthode sûre dépend de ton objectif : modifier la liste d’origine ou construire un résultat distinct. Remplacer des valeurs est plus simple car les positions restent en place.

Observe comment une boucle qui avance saute une valeur

Supposons qu’une boucle supprime les nombres pairs de [3, 8, 8, 5] et incrémente toujours i. À l’indice 1, elle supprime le premier 8. Le deuxième 8 glisse à l’indice 1, mais le passage suivant utilise l’indice 2. Le résultat est [3, 8, 5] : il reste un nombre pair. La condition était correcte ; c’est le déplacement après la suppression qui a posé problème.

Une boucle for-each sur une ArrayList ne doit pas non plus ajouter ou supprimer des éléments par l’intermédiaire de la liste. Elle utilise un itérateur dont l’état de parcours ne correspond plus à la liste modifiée. Java signale généralement une ConcurrentModificationException. Certaines modifications peuvent au contraire terminer la boucle sans avertissement et laisser un élément non parcouru. L’absence d’exception ne rend pas cette modification sûre.

Supprime à l’envers pour garder stables les positions non vérifiées

for (int i = numbers.size() - 1; i >= 0; i--) {
    if (numbers.get(i) % 2 == 0) {
        numbers.remove(i);
    }
}

Pour [3, 8, 8, 5], l’indice 3 contient 5 et reste inchangé. L’indice 2 contient 8, qui est supprimé. L’indice 1 contient toujours l’autre 8, qui est supprimé ensuite. L’indice 0 contient 3 et reste inchangé. Le résultat est [3, 5]. Une suppression décale les éléments à droite de l’indice actuel, que cette boucle inverse a déjà vérifiés.

Construis la liste des valeurs à conserver

Lorsque l’original doit rester inchangé, crée une nouvelle liste :

ArrayList<Integer> odds = new ArrayList<>();
for (int value : numbers) {
    if (value % 2 != 0) {
        odds.add(value);
    }
}

Cette boucle for-each est sûre car elle lit numbers et ajoute à une autre liste. Avec [3, 8, 8, 5] en entrée, odds contient [3, 5] et l’entrée contient toujours les quatre valeurs. Un tableau ne peut pas non plus rétrécir ; filtrer ses valeurs nécessite également un nouveau tableau ou une nouvelle liste.

Laisse un itérateur gérer sa propre suppression

Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    if (it.next() % 2 == 0) {
        it.remove();
    }
}

Importe java.util.Iterator. next() fournit l’élément suivant et it.remove() supprime l’élément qui vient d’être renvoyé tout en gardant cohérente la position de l’itérateur. Ne remplace pas cet appel par numbers.remove(...) dans cette boucle.

Une boucle while qui avance peut aussi fonctionner en incrémentant seulement lorsqu’aucun élément n’a été supprimé. Après une suppression, elle doit examiner à nouveau le même indice, où l’élément suivant est arrivé. Cela demande plus d’attention qu’une boucle inverse ou une nouvelle liste de résultat.

Les remplacements et les ajouts ont des effets différents

set(i, value) est sûr dans une boucle à indice car il ne change ni la taille ni les positions. Ajouter un élément à chaque passage tout en testant i < list.size() peut repousser indéfiniment la fin. Enregistre int originalSize = list.size(); et limite la boucle à cette borne lorsque chaque élément d’origine doit entraîner l’ajout d’une valeur.

Une String stocke du texte sous forme de séquence de valeurs char. Les indices commencent à 0, comme pour les tableaux et les listes. Un objet String ne peut pas changer après sa création : les méthodes qui produisent un texte modifié renvoient donc un résultat que tu dois conserver.

Un caractère est différent d’une chaîne

"Hello".length() vaut 5. "Hello".charAt(0) vaut 'H' et charAt(4) vaut 'o'. Un char utilise des apostrophes et contient une unité de code UTF-16 ; une String utilise des guillemets doubles et peut contenir zéro, une ou plusieurs de ces unités. "Java".charAt(0) == 'J' compare deux caractères primitifs. Comparer ce char avec "J" ne compile pas car les types diffèrent.

charAt(length()) dépasse la fin et provoque une StringIndexOutOfBoundsException. Même charAt(0) échoue pour "". Vérifie isEmpty() avant de lire le premier caractère d’une saisie.

length() compte les valeurs char UTF-16, qui ne correspondent pas toujours à des symboles affichés entiers. "café".length() vaut 4 ; "Hi 👋".length() vaut 5 car l’émoji de la main qui salue occupe deux positions char. Utilise ce décompte pour raisonner sur les indices de ces méthodes.

Parcours et teste les caractères

String text = "Programming in Java".toLowerCase();
int vowels = 0;
for (int i = 0; i < text.length(); i++) {
    char c = text.charAt(i);
    if ("aeiou".indexOf(c) >= 0) {
        vowels++;
    }
}

La conversion en minuscules permet au même test d’appartenance de reconnaître les voyelles majuscules et minuscules. Chaque indexOf(c) est positif ou nul lorsque le caractère apparaît dans "aeiou". Le compte atteint 6 : o, a, i, i, a, a. for (char c : text.toCharArray()) peut parcourir les mêmes valeurs sans indice.

La classe Character fournit des tests comme isLetter, isDigit, isWhitespace et isUpperCase. Character.isDigit('7') vaut true, tandis que Character.isLetter('7') vaut false. Character.toUpperCase(c) et toLowerCase(c) renvoient des valeurs char converties.

Les caractères ont aussi des codes numériques. 'a' + 1 produit l’int 98 ; (char) ('a' + 1) convertit ce code en 'b'. Pour un caractère représentant un chiffre ASCII, soustraire '0' donne sa valeur : '7' - '0' vaut 7. Soustraire le code de zéro fonctionne car les codes de ces chiffres sont consécutifs.

Lis la concaténation de gauche à droite

Dès que le côté gauche de + est du texte, le nombre suivant est assemblé comme du texte. Les parenthèses imposent l’addition numérique avant l’assemblage. Pour quelques assemblages dans une expression, + est une solution claire.

Enregistre le texte renvoyé

String name = "Lena";
name.toUpperCase();
System.out.println(name);
name = name.toUpperCase();

L’affichage montre toujours "Lena" : l’appel dont le résultat a été ignoré n’a pas modifié son objet. L’affectation fait ensuite référencer "LENA" par name. L’immuabilité des chaînes signifie que l’ancien texte reste inchangé même si d’autres variables le référencent. Conserver le résultat et modifier l’objet d’origine sont deux opérations différentes.

Le traitement de texte suit souvent une courte séquence : trouver un repère, vérifier qu’il existe, puis extraire la partie nécessaire. Des opérations de nettoyage peuvent préparer le texte avant une recherche ou une comparaison. Chaque opération sur une String renvoie un résultat sans modifier son objet d’origine.

Trouve des positions ou pose une question à réponse oui ou non

Pour "banana", indexOf('a') renvoie 1, indexOf("a", 2) renvoie 3 et lastIndexOf('a') renvoie 5. Le deuxième argument choisit où commence la recherche vers l’avant. Une recherche infructueuse donne -1, comme dans indexOf("x").

Utilise contains(text) lorsque tu as seulement besoin de savoir si un texte apparaît. startsWith(prefix) vérifie le début et endsWith(suffix) la fin. "report.pdf".endsWith(".pdf") vaut true. Ces recherches sont sensibles à la casse : "Hello".contains("hello") vaut false. Les méthodes de recherche d’indice acceptent un char ou une String ; contains prend du texte.

Une sous-chaîne s’arrête juste avant son indice de fin

String word = "programming";
String middle = word.substring(3, 7);
String tail = word.substring(3);

middle vaut "gram", avec les positions 3, 4, 5 et 6. Sa longueur est 7 - 3, soit 4. tail vaut "gramming", car omettre l’argument de fin permet d’aller jusqu’à la fin de la chaîne. Le début doit être positif ou nul et ne pas dépasser la fin ; la fin ne peut pas dépasser length(). Des bornes invalides provoquent une StringIndexOutOfBoundsException.

Pour une adresse électronique, trouve le séparateur avant l’extraction :

String email = "lena.ito@example.com";
int at = email.indexOf("@");
if (at != -1) {
    String user = email.substring(0, at);
    String domain = email.substring(at + 1);
}

Le séparateur est à l’indice 8. La première extraction se termine avant lui et donne "lena.ito" ; la seconde commence après lui et donne "example.com". Si le repère est absent, at vaut -1. Appeler substring(0, at) sans vérification échouerait. Commencer la seconde extraction à at conserverait le @ dans le domaine.

Nettoie seulement ce que l’opération vise

" hello ".trim() donne "hello" ; les espaces intérieurs restent. strip() traite des caractères blancs Unicode supplémentaires comme le cadratin. Cette méthode utilise la définition des caractères blancs de Java, qui n’inclut pas tous les caractères ressemblant à un espace. "banana".replace('a', 'o') donne "bonono". "ab".repeat(3) donne "ababab".

Vide et blanc sont différents

isEmpty() teste si la longueur est 0. isBlank() accepte aussi un texte composé uniquement de caractères blancs au sens de Java. Pour " ", la première méthode renvoie false et la seconde true. Utilise le test adapté à la règle de saisie. Pour nettoyer une réponse comme " Yes ", answer.trim().toLowerCase() renvoie "yes". Stocke ce texte renvoyé si la variable doit conserver la valeur nettoyée ; un simple answer.trim(); l’ignore.

Une ligne de données peut contenir plusieurs valeurs séparées par une virgule ou un autre repère. Le découpage produit un tableau de chaînes ; l’analyse syntaxique convertit ensuite certains champs en nombres. Vérifie la structure des données avant d’utiliser leurs positions.

Découpe en un tableau

String[] fields = "Ada,36,London".split(",");

Il y a trois champs : "Ada", "36" et "London". Les virgules ne sont pas conservées. fields.length vaut 3 et fields[1] est toujours du texte, pas un nombre.

Le séparateur transmis à split est une expression régulière, un motif qui n’est pas toujours du texte littéral. Une virgule représente une virgule, mais ., |, *, + et ? ont des significations particulières. Pour découper une chaîne de version sur des points littéraux, utilise "1.5.2".split("\\."). Deux barres obliques inverses dans la chaîne Java produisent l’unique barre oblique inverse du motif qui rend le point littéral. split("."), au contraire, correspond à des caractères individuels et produit un tableau vide dans cet exemple.

Gère les espaces et les parties vides

Découper "a b" sur " " produit trois parties : "a", "" et "b". Chaque séparateur est un espace, donc des espaces adjacents laissent une partie vide entre eux. Pour des suites de caractères blancs, utilise :

String[] words = "  red   green blue ".trim().split("\\s+");

Le résultat est [red, green, blue]. Nettoyer d’abord avec trim évite une première partie vide due à un séparateur initial. Par défaut, split supprime les parties vides finales : "a,b,,".split(",") ne donne que "a" et "b". Compte les champs réellement obtenus avant d’accéder à leurs indices.

Convertis chaque champ dans le type voulu

Integer.parseInt("42") renvoie l’int primitif 42. Integer.valueOf("-7") renvoie un objet Integer. Double.parseDouble("5.2") renvoie 5,2, en utilisant un point comme séparateur décimal quels que soient les paramètres régionaux de l’ordinateur. L’analyse d’un entier accepte du texte représentant un entier sans point décimal. Integer.parseInt("4.5") échoue au lieu d’arrondir.

Nettoie les champs avec trim avant leur analyse, surtout le texte représentant un entier : Integer.parseInt(" 42") provoque une NumberFormatException. Le découpage sur les virgules ne supprime pas les espaces autour des champs. Un nombre de champs correct ne garantit pas non plus qu’un champ contient un nombre valide.

Lis un enregistrement complet

String line = "Amira,10.5,63";
String[] parts = line.split(",");
if (parts.length == 3) {
    String name = parts[0].trim();
    double distanceKm = Double.parseDouble(parts[1].trim());
    int minutes = Integer.parseInt(parts[2].trim());
    double pace = minutes / distanceKm;
    System.out.println(name + ": " + pace + " min/km");
}

La distance est de 10,5 km, le temps est de 63 minutes et l’allure est de 6,0 min/km. La ligne incomplète "Amira,10.5" ne contient que deux champs ; sans la vérification du nombre de champs, parts[2] provoquerait une ArrayIndexOutOfBoundsException. Un programme peut ignorer ou signaler cet enregistrement incomplet avant d’utiliser une position manquante.

Convertis ou assemble à nouveau du texte

String.valueOf(42) et Integer.toString(42) donnent tous deux "42". String.join(", ", List.of("Oslo", "Lima", "Pune")) donne "Oslo, Lima, Pune", en insérant des séparateurs uniquement entre les parties. La méthode accepte une liste, un tableau ou des chaînes transmises en arguments séparés. L’assemblage ne fait ni analyse syntaxique ni calcul : il combine les chaînes fournies.

Deux variables peuvent contenir du texte avec les mêmes caractères sans référencer le même objet String. Choisis une comparaison selon la question posée : égalité des contenus, égalité des contenus sans tenir compte de la casse, ou texte qui vient en premier dans l’ordre de Java.

Utilise equals pour les contenus

String answer = new String("yes");
System.out.println(answer == "yes");
System.out.println(answer.equals("yes"));

Le premier résultat est false : l’objet créé séparément n’est pas celui du littéral. Le second est true car les caractères correspondent. Des littéraux identiques comme dans "yes" == "yes" partagent un objet et peuvent donner l’impression que la comparaison d’identité est fiable. Un texte obtenu à l’exécution peut utiliser des objets nouveaux ou existants : l’identité ne permet donc pas de tester si une saisie correspond.

equalsIgnoreCase ignore la casse des lettres : "YES".equalsIgnoreCase("yes") vaut true. La méthode ne supprime pas les espaces. Pour accepter aussi les espaces autour de la saisie, nettoie-la avant la comparaison.

Pour une variable qui peut valoir null, appelle la méthode sur un littéral connu qui n’est pas null : "yes".equals(answer) renvoie false pour null. answer.equals("yes") provoque une NullPointerException si answer vaut null, car aucun objet ne reçoit l’appel.

Une boucle de commande peut tester !command.equals("quit"). Le ! inverse le résultat de l’égalité de contenu. command != "quit" teste les références et peut maintenir une boucle en cours même lorsque les caractères saisis sont « quit ».

Interprète le signe de compareTo

a.compareTo(b) compare les valeurs char UTF-16 dans l’ordre. La méthode renvoie un nombre négatif si a vient avant b, zéro si les chaînes sont égales et un nombre positif si la première vient après. Seul le signe compte pour l’ordre ; le résultat n’est pas nécessairement exactement -1 ou 1.

Les nombres stockés sous forme de texte ne suivent donc pas l’ordre numérique. Convertis-les lorsque la tâche porte sur des nombres. Les lettres majuscules anglaises non accentuées précèdent les minuscules non accentuées, donc "Zebra" vient avant "apple". Dans cet ordre, "Émile", avec sa lettre accentuée, vient après "Zoe". compareToIgnoreCase ignore la casse ; un classement selon les règles d’un dictionnaire propre à une langue nécessite java.text.Collator.

Réutilise le schéma du minimum pour les noms

Pour une liste non vide [Mia, Ahmed, Lucia] :

String first = names.get(0);
for (String name : names) {
    if (name.compareTo(first) < 0) {
        first = name;
    }
}

"Mia" est le candidat initial. "Ahmed" vient avant et devient le candidat ; "Lucia" ne le remplace pas. Le résultat est "Ahmed". Vérifie que la liste n’est pas vide avant de lire son premier élément.

Un char individuel est une valeur primitive, donc word.charAt(0) == 'A' est une comparaison correcte de caractères une fois que l’on sait que le mot n’est pas vide. Le problème avec == concerne l’identité des objets, pas toutes les comparaisons impliquant du texte.

Un StringBuilder contient du texte modifiable. Il est utile lorsqu’une boucle ajoute de nombreux morceaux ou lorsque des caractères doivent être modifiés en place. Pour quelques assemblages dans une expression, + est clair, mais reconstruire sans cesse une String qui grandit peut copier son contenu accumulé de nombreuses fois.

Ajoute des morceaux et termine par une String

StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
    if (i > 1) {
        sb.append(", ");
    }
    sb.append(i);
}
String result = sb.toString();

Aucune importation n’est nécessaire. append ajoute des chaînes, des char, des nombres ou des booléens à la fin. Le premier passage ajoute seulement 1 ; le deuxième ajoute ", " puis 2. Le résultat est "1, 2, 3, 4, 5". Placer un séparateur après chaque nombre laisserait un séparateur indésirable à la fin. Pour une liste de chaînes existante, String.join(", ", list) gère directement les séparateurs.

Répéter text += piece dans une boucle crée de nouveaux résultats String immuables. Le préfixe accumulé doit être inclus chaque fois, donc la quantité copiée peut croître de façon quadratique à mesure qu’un long résultat grandit. Un constructeur de chaîne conserve un tampon modifiable et y ajoute des éléments sans reconstruire tout le préfixe à chaque passage.

Modifie des positions et des portions

length() et charAt(i) lisent le constructeur comme une String. Les indices décrivent son état actuel ; une insertion ou une suppression peut modifier les positions suivantes.

Commence par new StringBuilder("Jva"). insert(1, 'a') produit "Java" ; setCharAt(0, 'j') donne ensuite "java". Pour "2026-10-22", delete(4, 7) supprime les positions 4, 5 et 6, ce qui laisse "2026-22". Remplacer les positions 7 à 9 de "I like tea" par "coffee" donne "I like coffee".

Ne chaîne que les méthodes qui renvoient le constructeur

new StringBuilder().append("a").append(1).append('b').toString() donne "a1b". Les appels à append renvoient le même constructeur, ce qui permet un autre appel. Les méthodes de modification présentées ici renvoient aussi le constructeur, sauf setCharAt, qui renvoie void et nécessite une instruction distincte.

reverse() modifie l’objet receveur. Si sb contient "stressed", alors String r = sb.reverse().toString(); laisse à la fois r et le texte du constructeur avec la valeur "desserts". Pour préserver le constructeur d’origine, inverse un nouveau constructeur créé à partir de son texte.

Compare les contenus finaux

Pour vérifier un palindrome, ajoute la forme minuscule de chaque lettre de "Was it a car or a cat I saw". Le texte nettoyé est "wasitacaroracatisaw". Inverse un nouveau constructeur contenant ce texte, convertis-le en String et compare avec clean.equals(reversed). La comparaison vaut true.

StringBuilder ne redéfinit pas equals pour comparer les contenus. Des constructeurs distincts contenant "abc" ne sont pas égaux selon cette méthode, et un constructeur n’est pas égal à une String. Convertis-les d’abord : sb1.toString().equals(sb2.toString()) compare le texte réel.