Accueil > Programmer avec Java > Structures de données >

📚 Strings

Survol et attentes

Objectifs d’apprentissage

À la fin de cette leçon vous devrez être en mesure de :

• Analyser le contenu des String avec des méthodes comme charAt, length, toCharArray, indexOf, lastIndexOf, substring, startsWith, endsWith et contains.
• Nettoyer les entrées texte en utilisant des méthodes comme replace, strip et split.
• Se familiariser avec les méthodes “parse” pour convertir des String en types primitifs, notamment Integer.parseInt et Double.parseDouble.

Critères de succès

• Je peux utiliser une variété d’entrées texte et extraire leurs informations avec confiance dans mes propres programmes.

Méthodes qui utilisent un drapeau booléen (donne une réponse vrai/faux)

Ces méthodes sont utiles pour sonder le contenu d’un texte, soit comme réponse en soi ou comme condition pour une prochaine étape de traitement. Par exemple, on peut vérifier si un texte commence ou finit avec une certaine lettre (ou séquence de lettres) ou s’il contient un mot spécifique.

Voici quelques exemples :

String s1 = "Hello, World!";
boolean b1 = s1.startsWith("Hello"); // true
boolean b2 = s1.endsWith("World!"); // true
boolean b3 = s1.contains(" "); // true

Méthodes qui utilisent la nature tableau des String (se basent sur des index)

La valeur de chaque String est un tableaux de bytes représentant chacun des caractères Unicode dans le texte. On peut alors accéder à chaque caractère individuellement en utilisant un index et une méthode appropriée. On peut aussi sonder le texte et recevoir un index en retour au lieu d’une valeur booléenne.

charAt, length et toCharArray

La méthode charAt est utile pour accéder à un caractère spécifique dans une chaîne de caractères. On utilise un index pour spécifier la position du caractère, en commençant à 0 pour le premier caractère. Si l’index est plus grand que la longueur de la chaîne, une exception StringIndexOutOfBoundsException sera lancée. On peut obtenir la longueur de la chaîne avec la méthode length(). On peut aussi convertir une chaîne de caractères en un tableau de caractères avec la méthode toCharArray.

String s1 = "Hello, World!";
char c1 = s1.charAt(0); // 'H'
char c2 = s1.charAt(7); // 'W'
char c3 = s1.charAt(s1.length() - 1); // '!'
for (char c : s1.toCharArray()) {
    System.out.println((int)c); // affiche le code Unicode de chaque caractère
}

• Notez que la valeur de retour de charAt est un char et non un String. Ça peut être utile pour les comparaisons (avec ==) ou pour obtenir la valeur Unicode, mais ça peut aussi causer des problèmes si on tente de le traiter comme un String.

indexOf et lastIndexOf

Ces méthodes sont utiles pour trouver la position d’un caractère ou d’une séquence de caractères dans une chaîne de caractères. La méthode indexOf retourne la position du premier caractère trouvé, tandis que lastIndexOf retourne la position du dernier caractère trouvé. Si le caractère ou la séquence n’est pas trouvé, -1 est retourné.

String s1 = "Hello, World!";
int i1 = s1.indexOf("o"); // 4
int i2 = s1.lastIndexOf("o"); // 8
int i3 = s1.indexOf("z"); // -1

La méthode indexOf peut prendre un deuxième argument pour spécifier la position de départ de la recherche. Ça peut être utile pour trouver des occurrences multiples d’un caractère ou d’une séquence.

String s1 = "Hello, World!";
int countOs = 0;
int i = 0;
while (i != -1 && i < s1.length()) {
    i = s1.indexOf("o", i); // commencer la recherche à partir de la position i
    if (i != -1) {
        countOs++;
        i++; // continuer la recherche après le dernier "o" trouvé
    }
}
System.out.println("On a trouvé " + countOs " 'o' dans le texte.");

substring

Cette méthode est utile pour extraire une partie d’une chaîne de caractères. On spécifie la position de départ et la position de fin (exclusif) pour extraire la sous-chaîne. Si on ne spécifie pas la position de fin, la sous-chaîne sera extraite jusqu’à la fin de la chaîne.

String s1 = "Hello, World!";
String s2 = s1.substring(7); // "World!"
String s3 = s1.substring(7, 9); // "Wo"

Méthodes pour nettoyer les String

replace

Cette méthode est utile pour remplacer un caractère ou une séquence de caractères par un autre. Par exemple, si on veut remplacer tous les espaces par des tirets dans une chaîne de caractères, on peut utiliser la méthode replace. Même chose pour remplacer les virgules avec des points.

Voici un exemple :

String s1 = "Dé connecté";
String s2 = s1.replace(" ", "-"); // "Dé-connecté"
String s3 = s1.replace(" ","").replace("Dé","Re"); // "Reconnecté"

• Notez que le texte original n’est pas modifié. La méthode replace retourne une nouvelle chaîne de caractères avec les modifications.
• Notez qu’on peut remplacer quelque chose avec le texte vide "" pour l’éliminer.
• On peut aussi chaîner les appels de méthode pour effectuer plusieurs remplacements en une seule ligne. Ça marche parce que la méthode replace retourne une nouvelle chaîne de caractères qui devient le String utilisé pour la prochaine appel de replace.

strip

Cette méthode est pratique pour éliminer les espaces blancs inutiles au début et à la fin d’une chaîne de caractères. Elle est surtout importante avant de comparer des String, parce que les espaces feront partie de la comparaison s’ils sont encore présents.

Voici un exemple :

"  Hello, World!  ".equals("Hello, World!"); // false
"  Hello, World!  ".strip().equals("Hello, World!"); // true; strip enlève les espaces initiaux et finaux

Il existe aussi la méthode trim qui fait la même chose, mais elle ne reconnaît pas les espaces Unicode. La méthode strip est plus moderne et plus fiable.

split

Cette méthode est utile pour séparer une ligne de texte, obtenu notamment avec la méthode nextLine de Scanner, en plusieurs éléments. Par exemple, si on a une ligne de texte avec des mots séparés par des espaces, on peut les séparer en utilisant un espace " " comme délimiteur. Un format de fichier commun est le CSV (Comma Separated Values) où les valeurs sont séparées par des virgules ou des points-virgules. La méthode split est utile pour séparer ces valeurs en utilisant "," (ou ;) comme délimiteur.

Voici un exemple où on doit utiliser strip pour nettoyer les valeurs une fois qu’elles ont été séparées :

String s1 = "Hello, World!";
String[] words = s1.split(","); // ["Hello", " World!"]
for (int i = 0; i < words.length; i++) {
    words[i] = words[i].strip();
} // ["Hello", "World!"]

Alternative : Scanner

Une autre façon de séparer les valeurs d’une ligne de texte est d’utiliser un objet Scanner. Voici un exemple :

Scanner sc = new Scanner("Hello, World!");
sc.useDelimiter(",");
while (sc.hasNext()) {
    System.out.println(sc.next().strip());
}
sc.close();

• On utilise la méthode useDelimiter pour spécifier le délimiteur entre les différents éléments du texte.
• On utilise la méthode hasNext pour vérifier s’il reste des éléments à traiter dans la boucle.
• On peut immédiatement appliquer strip sur chaque élément pour nettoyer les espaces blancs en le chaînant avec next.

Et voici un autre exemple où on connaît le type des données à chaque position sur la ligne :

// un Scanner pour la source de données
Scanner sc = new Scanner("Alice, 25, 3.14\nBob, 30, 2.71\n");
while (sc.hasNextLine()) { // boucle pour traiter multiples lignes dans la source
  String line = sc.nextLine();
  Scanner lsc = new Scanner(line); // un autre Scanner pour chaque ligne
  lsc.useDelimiter(",");
  String name = lsc.next().strip();
  int age = lsc.nextInt();
  double rating = lsc.nextDouble();
  lsc.close();
  System.out.printf("%s a %d ans et une cote de %.2f\n", name, age, rating);
}
sc.close();

La sortie de ce code sera :

Alice a 25 ans et une cote de 3.14
Bob a 30 ans et une cote de 2.71

• On utilise un Scanner pour traiter chaque ligne de texte.
• Rappel : le caractère \n est le caractère pour indiquer une nouvelle ligne.
• Connaissant le format des données, on peut utiliser la méthode next, nextInt et nextDouble aux endroits appropriés.

Les méthodes “parse”

Ces méthodes sont utiles pour convertir des chaînes de caractères en types primitifs. Par exemple, si on veut convertir une chaîne de caractères en un entier, on peut utiliser la méthode Integer.parseInt.

Prenons le dernier exemple de l’alternative avec le Scanner. Si on utilise split sur chaque ligne au lieu d’un Scanner, on n’aura pas accès aux méthodes nextInt et nextDouble pour convertir les valeurs en entiers et en doubles. On doit alors utiliser les méthodes “parse” pour convertir les chaînes de caractères en types primitifs.

Voici ce même exemple réécrit avec split et les méthodes “parse” appropriées:

Scanner sc = new Scanner("Alice, 25, 3.14\nBob, 30, 2.71\n");
while (sc.hasNextLine()) { // boucle pour traiter multiples lignes dans la source
  String line = sc.nextLine();
  String[] values = line.split(",");
  String name = values[0].strip();
  int age = Integer.parseInt(values[1].strip());
  double rating = Double.parseDouble(values[2].strip());
  System.out.printf("%s a %d ans et une cote de %.2f\n", name, age, rating);
}
sc.close();

• Notez qu’on réfère aux valeurs du tableau values avec leurs index
• Notez aussi qu’il faut utiliser strip pour nettoyer les valeurs avant de les convertir en entiers ou en doubles, contrairement aux méthodes nextInt et nextDouble qui font ça automatiquement.

Exercices

🛠️ Pratique

Vous rendre sur le site codingbat.com pour les exercices suivants.

1. Travaillez dans la section “String-1” pour vous familiariser avec les méthodes de la classe String.
2. Travaillez dans la section “String-2” pour ajouter des boucles à vos analyses des entrées texte.