Bienvenue dans ce tutoriel sur la manipulation de chaînes de caractères en Java ! Les chaînes de caractères sont des éléments fondamentaux dans le développement logiciel, utilisées pour représenter et manipuler du texte. Dans ce guide, nous explorerons les différentes techniques et méthodes offertes par Java pour travailler efficacement avec des chaînes.
accès rapide
- Introduction aux Chaînes de Caractères
- Opérations de Base sur les Chaînes de Caractères
- Méthodes de la Classe String
- Conversion entre Chaînes et autres Types
- Chaine de type « TEXT BLOCKS » de Java SE
- Bonnes pratiques et Astuces
- Exemples Pratiques et Applications
- Quiz de ce tuto
Introduction aux Chaînes de Caractères
La démo:
1. Qu’est-ce qu’une String en Java ?
En Java, une String est une séquence de caractères. Elle est utilisée pour stocker et manipuler du texte. La classe String fait partie du package java.lang, ce qui signifie qu’elle est automatiquement importée dans tous les programmes Java. Les chaînes de caractères sont très couramment utilisées, et Java offre une riche bibliothèque de méthodes pour les manipuler.
Exemple de déclaration de String :
String message;Découvrons encore plus :
En Java, une chaîne de caractères est représentée par le type java.lang.String. La déclaration d’une chaîne se fait en utilisant le mot-clé String, suivi du nom de la variable. Voici un exemple de déclaration de chaînes :
java.lang.String firstName;
java.lang.String lastName;2. Déclaration et Initialisation des Strings
Il existe plusieurs façons de déclarer et initialiser des Strings en Java :
2.1. Littéral de chaîne :
String message = "Hello, Java!";2.2. Utilisation du mot-clé new :
String message = new String("Hello, Java!");2.3. À partir d’un tableau de caractères :
char[] helloArray = { 'H', 'e', 'l', 'l', 'o', '!' };
String helloString = new String(helloArray);3. Immutabilité des Strings
Une caractéristique clé des Strings en Java est leur immutabilité. Une fois qu’une String est créée, elle ne peut pas être modifiée. Toute opération qui semble modifier une String crée en réalité une nouvelle chaîne.
Exemple d’immutabilité :
public class StringImmutability {
public static void main(String[] args) {
String original = "Hello";
String modified = original.concat(", World!");
System.out.println("Original String: " + original); // Affiche "Hello"
System.out.println("Modified String: " + modified); // Affiche "Hello, World!"
}
}Dans cet exemple, la chaîne original reste inchangée après l’opération concat.
Opérations de Base sur les Chaînes de Caractères
La démo :
1. Concaténation :
La concaténation de chaînes consiste à joindre deux ou plusieurs chaînes pour former une seule chaîne. En Java, il existe plusieurs méthodes pour concaténer des chaînes de caractères.
1.1 Utilisation de l’Opérateur +
L’opérateur + peut être utilisé pour concaténer des chaînes de caractères. Lorsque l’opérateur + est utilisé entre des chaînes de caractères, Java les concatène pour former une seule chaîne.
String prenom = "John";
String nom = "Doe";
String nomComplet = prenom + " " + nom;
System.out.println("Nom complet : " + nomComplet);
Explication :
+: L’opérateur+est utilisé pour concaténer (joindre) plusieurs chaînes.- Résultat : La sortie affichera « Nom complet : John Doe », montrant que les chaînes « John » et « Doe » ont été concaténées pour former le nom complet.
1.2 Utilisation de la Méthode concat()
La méthode concat() de la classe String peut également être utilisée pour concaténer des chaînes de caractères. Elle prend en argument une autre chaîne à concaténer avec la chaîne d’origine.
String str1 = "Bonjour";
String str2 = " le monde";
String result = str1.concat(str2); // "Bonjour le monde"Comparaison entre l’Opérateur + et la Méthode concat()
Avantages de l’opérateur + :
- Facilité d’utilisation : L’opérateur
+est simple à comprendre et à utiliser. - Polyvalence : En plus de concaténer des chaînes de caractères, il peut être utilisé pour concaténer d’autres types de données, ce qui rend le code plus lisible dans certains cas.
Inconvénients de l’opérateur + :
- Performance : L’opérateur
+crée souvent des objets temporaires lors de la concaténation de chaînes de caractères, ce qui peut affecter les performances, surtout lorsqu’il est utilisé dans des boucles ou dans des applications nécessitant beaucoup de manipulations de chaînes.
Avantages de la méthode concat() :
- Performance : La méthode
concat()est souvent plus performante que l’opérateur+car elle évite la création d’objets temporaires lors de la concaténation. - Clarté du code : Son utilisation explicite peut rendre le code plus clair et plus lisible dans certaines situations.
Inconvénients de la méthode concat() :
- Limitation : Elle ne peut concaténer que des chaînes de caractères, ce qui limite son utilisation à cette tâche spécifique.
2. Comparaison de Chaînes de Caractères
Comparer des chaînes de caractères permet de déterminer si elles sont égales ou d’établir leur ordre lexicographique.
- Utilisation de
equals()pour vérifier l’égalité :
String str1 = "Java";
String str2 = "java";
boolean isEqual = str1.equals(str2);
System.out.println(isEqual); // Affiche "false"Différence entre == et equals() dans les Chaînes de Caractères en Java
En Java, comparer des chaînes de caractères (String) avec == et equals() donne des résultats différents car ces deux opérateurs ont des significations distinctes.
2.1. Comparaison avec ==
L’opérateur == compare les références des objets, c’est-à-dire les adresses mémoire auxquelles ils pointent. Lorsque vous utilisez == pour comparer des chaînes de caractères, vous vérifiez si les deux variables de chaînes font référence au même objet en mémoire. Voici ce qui se passe en Java :
- Lorsque vous déclarez une chaîne de caractères littérale (par exemple,
String str = "Bonjour";), Java vérifie d’abord s’il existe déjà une chaîne identique dans la mémoire de littéraux de chaîne. - Si une chaîne identique existe déjà, la variable de chaîne nouvellement déclarée (
str) pointera vers cette chaîne existante. - Si aucune chaîne identique n’existe, une nouvelle chaîne sera créée dans la mémoire et la variable de chaîne (
str) pointera vers cette nouvelle chaîne.
Donc, lorsque vous comparez deux chaînes de caractères avec ==, vous comparez essentiellement les adresses mémoire auxquelles elles pointent. Si les deux chaînes pointent vers la même adresse mémoire, == renverra true, sinon il renverra false.
2.2. Comparaison avec equals()
La méthode equals() est une méthode définie dans la classe Object, et elle est souvent substituée dans la classe String pour comparer le contenu des chaînes de caractères. Lorsque vous appelez equals() sur des chaînes de caractères, il compare les séquences de caractères qu’elles contiennent.
- La méthode
equals()vérifie si les caractères dans les deux chaînes sont les mêmes, c’est-à-dire si elles ont la même longueur et que chaque caractère à la même position dans chaque chaîne est identique. - Si les contenus des deux chaînes sont identiques,
equals()renverratrue, sinon il renverrafalse.
Exemple Pratique
public class StringComparisonExample {
public static void main(String[] args) {
// Déclaration de chaînes de caractères
String str1 = "Bonjour";
String str2 = "Bonjour";
String str3 = new String("Bonjour");
// Comparaison avec ==
boolean result1 = (str1 == str2);
boolean result2 = (str1 == str3);
// Comparaison avec equals()
boolean result3 = str1.equals(str2);
boolean result4 = str1.equals(str3);
// Affichage des résultats
System.out.println("Comparaison avec == :");
System.out.println("str1 == str2 : " + result1); // Affiche true
System.out.println("str1 == str3 : " + result2); // Affiche false
System.out.println("Comparaison avec equals() :");
System.out.println("str1.equals(str2) : " + result3); // Affiche true
System.out.println("str1.equals(str3) : " + result4); // Affiche true
}
}
Explication
- Comparaison avec
==:str1 == str2retournetruecarstr1etstr2pointent vers le même objet en mémoire. Les littéraux de chaîne de caractères en Java qui sont identiques sont internés (stockés dans une même mémoire de littéraux de chaîne).str1 == str3retournefalsecarstr3est un nouvel objet créé avec le mot-clénew, ce qui signifie qu’il occupe un emplacement différent en mémoire.
- Comparaison avec
equals():str1.equals(str2)retournetruecar les contenus des chaînes sont identiques.str1.equals(str3)retourne égalementtruecar, encore une fois, les contenus des chaînes sont identiques, même sistr1etstr3sont des objets différents en mémoire.
- Utilisation de
equalsIgnoreCase()pour ignorer la casse :
String str1 = "Java";
String str2 = "java";
boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2);
System.out.println(isEqualIgnoreCase); // Affiche "true"- Utilisation de
compareTo()pour la comparaison lexicographique :
String str3 = "Apple";
String str4 = "Banana";
int result = str3.compareTo(str4);
System.out.println(result); // Affiche un nombre négatif car "Apple" est avant "Banana"La méthode compareTo() renvoie un nombre négatif si la chaîne d’origine précède la chaîne comparée, un nombre positif si elle la suit, et zéro si elles sont égales.
3. Extraction de Sous-chaînes
L’extraction de sous-chaînes permet d’obtenir une partie d’une chaîne de caractères.
- Utilisation de
substring():
String phrase = "Hello, World!";
String sousChaine = phrase.substring(7, 12);
System.out.println(sousChaine); // Affiche "World"La méthode substring(int beginIndex, int endIndex) extrait les caractères de l’index beginIndex à endIndex - 1.
4. Conversion de Chaînes en Majuscules et Minuscules
Convertir des chaînes de caractères en majuscules ou en minuscules est utile pour normaliser les données.
- Utilisation de
toUpperCase()pour convertir en majuscules :
String texte = "Bonjour";
String majuscules = texte.toUpperCase();
System.out.println(majuscules); // Affiche "BONJOUR"- Utilisation de
toLowerCase()pour convertir en minuscules :
String minuscules = texte.toLowerCase();
System.out.println(minuscules); // Affiche "bonjour"Ces méthodes créent une nouvelle chaîne de caractères avec toutes les lettres converties en majuscules ou en minuscules, respectivement.
Méthodes de la Classe String
La classe String en Java offre de nombreuses méthodes pour manipuler les chaînes de caractères. Voici un aperçu des méthodes les plus couramment utilisées, avec des exemples d’implémentation.
La démo :
1. length()
La méthode length() renvoie la longueur de la chaîne (le nombre de caractères).
public class StringLengthExample {
public static void main(String[] args) {
String texte = "Bonjour, monde!";
int longueur = texte.length();
System.out.println("Longueur: " + longueur); // Affiche "Longueur: 15"
}
}2. charAt(int index)
La méthode charAt() renvoie le caractère à l’index spécifié.
public class StringCharAtExample {
public static void main(String[] args) {
String texte = "Bonjour";
char caractere = texte.charAt(3);
System.out.println("Caractère à l'index 3: " + caractere); // Affiche "Caractère à l'index 3: j"
}
}3. indexOf(String str)
La méthode indexOf() renvoie l’index de la première occurrence de la sous-chaîne spécifiée, ou -1 si elle n’est pas trouvée.
public class StringIndexOfExample {
public static void main(String[] args) {
String phrase = "Apprendre Java est amusant";
int index = phrase.indexOf("Java");
System.out.println("Index de 'Java': " + index); // Affiche "Index de 'Java': 10"
}
}4. substring(int beginIndex, int endIndex)
La méthode substring() renvoie une nouvelle chaîne qui est une sous-chaîne de cette chaîne.
public class StringSubstringExample {
public static void main(String[] args) {
String phrase = "Apprendre Java est amusant";
String sousChaine = phrase.substring(10, 14);
System.out.println("Sous-chaîne: " + sousChaine); // Affiche "Sous-chaîne: Java"
}
}5. toUpperCase() et toLowerCase()
Les méthodes toUpperCase() et toLowerCase() renvoient la chaîne en majuscules ou en minuscules, respectivement.
public class StringCaseExample {
public static void main(String[] args) {
String texte = "Bonjour";
String enMajuscules = texte.toUpperCase();
String enMinuscules = texte.toLowerCase();
System.out.println("En majuscules: " + enMajuscules); // Affiche "En majuscules: BONJOUR"
System.out.println("En minuscules: " + enMinuscules); // Affiche "En minuscules: bonjour"
}
}6. replace(CharSequence target, CharSequence replacement)
La méthode replace() remplace toutes les occurrences d’une sous-chaîne par une autre.
public class StringReplaceExample {
public static void main(String[] args) {
String phrase = "La programmation en Java est amusante";
String nouvellePhrase = phrase.replace("Java", "Python");
System.out.println("Nouvelle phrase: " + nouvellePhrase); // Affiche "Nouvelle phrase: La programmation en Python est amusante"
}
}
7. trim()
La méthode trim() supprime les espaces de début et de fin de la chaîne.
public class StringTrimExample {
public static void main(String[] args) {
String texte = " Bonjour ";
String texteTrimmed = texte.trim();
System.out.println("Texte sans espaces: '" + texteTrimmed + "'"); // Affiche "Texte sans espaces: 'Bonjour'"
}
}
8. split(String regex)
La méthode split() divise la chaîne en un tableau de chaînes autour des correspondances de l’expression régulière donnée.
public class StringSplitExample {
public static void main(String[] args) {
String phrase = "Un,deux,trois,quatre";
String[] parties = phrase.split(",");
for (String part : parties) {
System.out.println(part);
}
// Affiche :
// Un
// deux
// trois
// quatre
}
}
9. String.format()
En Java, le formatage de chaînes de caractères permet de créer des chaînes bien structurées et lisibles. On utilise généralement la méthode String.format() ou la classe Formatter pour formater les chaînes. Voici un exemple détaillé utilisant String.format() :
public class StringFormattingExample {
public static void main(String[] args) {
// Variables à formater
String name = "John";
int age = 30;
double salary = 12345.6789;
// Formatage de chaînes avec String.format()
String formattedString = String.format("Name: %s, Age: %d, Salary: %.2f", name, age, salary);
System.out.println(formattedString); // Affiche "Name: John, Age: 30, Salary: 12345.68"
// Autre exemple avec des dates
LocalDate date = LocalDate.now();
String formattedDate = String.format("Current Date: %tF", date);
System.out.println(formattedDate); // Affiche "Current Date: YYYY-MM-DD"
// Formatage en colonne pour affichage tabulaire
String header = String.format("%-10s %-10s %-10s", "Name", "Age", "Salary");
String row1 = String.format("%-10s %-10d %-10.2f", "Alice", 28, 9876.543);
String row2 = String.format("%-10s %-10d %-10.2f", "Bob", 35, 10500.75);
System.out.println(header);
System.out.println(row1);
System.out.println(row2);
// Affiche :
// Name Age Salary
// Alice 28 9876.54
// Bob 35 10500.75
}
}
Explication
- Variables à Formater :
name,age, etsalarysont les variables à insérer dans la chaîne formatée.
- String.format() :
- La méthode
String.format()permet de créer une chaîne formatée en utilisant des spécificateurs de format. %s: Place unString.%d: Place un entier (int).%.2f: Place un nombre à virgule flottante (double) avec deux décimales.%tF: Formate une date en utilisant le formatYYYY-MM-DD.
- La méthode
- Alignement et Largeur de Colonne :
%-10s: Formate une chaîne de caractères sur 10 caractères, alignée à gauche.%-10d: Formate un entier sur 10 caractères, aligné à gauche.%-10.2f: Formate un nombre flottant sur 10 caractères avec deux décimales, aligné à gauche.
- Affichage Tabulaire :
- Crée des en-têtes et des lignes alignées pour une meilleure lisibilité des données tabulaires.
Ce code montre comment formater des chaînes de caractères pour différents types de données, aligner les résultats et afficher des informations formatées de manière lisible.
10. Exemple Complet
Voici un exemple qui combine plusieurs des méthodes ci-dessus :
public class StringMethodsExample {
public static void main(String[] args) {
String texte = " Bonjour, monde! Apprendre Java est amusant. ";
// Longueur
System.out.println("Longueur: " + texte.length());
// Caractère à un index spécifique
System.out.println("Caractère à l'index 5: " + texte.charAt(5));
// Index d'une sous-chaîne
System.out.println("Index de 'Java': " + texte.indexOf("Java"));
// Sous-chaîne
System.out.println("Sous-chaîne: " + texte.substring(10, 15));
// Conversion en majuscules et minuscules
System.out.println("En majuscules: " + texte.toUpperCase());
System.out.println("En minuscules: " + texte.toLowerCase());
// Remplacement de sous-chaîne
System.out.println("Remplacement: " + texte.replace("Java", "Python"));
// Suppression des espaces de début et de fin
System.out.println("Texte sans espaces: '" + texte.trim() + "'");
// Division de la chaîne
String[] mots = texte.trim().split(" ");
for (String mot : mots) {
System.out.println(mot);
}
}
}
Conversion entre Chaînes et les autres Types
La conversion entre chaînes de caractères et types primitifs est une opération courante en programmation Java, permettant de transformer des données textuelles en valeurs numériques et vice versa. Cette partie explore les méthodes pour effectuer ces conversions.
La démo :
Conversion de Chaînes en Types Primitifs
En Java, les méthodes parseXxx() sont utilisées pour convertir des chaînes en types primitifs. Par exemple, la méthode parseInt() permet de convertir une chaîne en un entier (int).
String strEntier = "42";
int entier = Integer.parseInt(strEntier); // 42
String strDecimale = "3.14";
double decimale = Double.parseDouble(strDecimale); // 3.14
De même, il existe des méthodes pour convertir des chaînes en d’autres types primitifs tels que parseDouble(), parseFloat(), parseLong(), etc.
Conversion de Types Primitifs en Chaînes
La classe String offre plusieurs méthodes pour convertir des types primitifs en chaînes de caractères. L’une des méthodes les plus couramment utilisées est valueOf(), qui prend en argument un type primitif et renvoie sa représentation sous forme de chaîne.
int entier = 42;
String strEntier = String.valueOf(entier); // "42"
double decimale = 3.14;
String strDecimale = String.valueOf(decimale); // "3.14"
Conversion des Chaînes vers les Objets Enveloppes
Les méthodes valueOf() des classes enveloppes convertissent les chaînes en objets enveloppes.
String strEntier = "42";
Integer entier = Integer.valueOf(strEntier); // Integer(42)
String strDecimale = "3.14";
Double decimale = Double.valueOf(strDecimale); // Double(3.14)Ces méthodes peuvent également lancer une NumberFormatException, il est donc prudent de gérer les exceptions comme montré précédemment.
Gestion des Erreurs de Conversion
Il est important de noter que les méthodes de conversion peuvent lever des exceptions si la chaîne n’est pas dans un format approprié pour être convertie en type primitif. Il est donc recommandé d’encadrer les appels de ces méthodes avec des blocs try-catch pour gérer les éventuelles exceptions.
String strEntier = "42a";
try {
int entier = Integer.parseInt(strEntier); // NumberFormatException
} catch (NumberFormatException e) {
System.out.println("Erreur de format : " + e.getMessage());
}Exemple Complet
Voici un exemple complet démontrant différentes conversions :
public class ConversionDemo {
public static void main(String[] args) {
// Conversion des types primitifs vers chaînes
int entier = 42;
String strEntier = Integer.toString(entier);
System.out.println("Integer to String: " + strEntier);
double decimale = 3.14;
String strDecimale = Double.toString(decimale);
System.out.println("Double to String: " + strDecimale);
// Conversion des chaînes vers types primitifs
String strEntier2 = "42";
try {
int entier2 = Integer.parseInt(strEntier2);
System.out.println("String to Integer: " + entier2);
} catch (NumberFormatException e) {
System.out.println("Erreur de format : " + e.getMessage());
}
String strDecimale2 = "3.14";
try {
double decimale2 = Double.parseDouble(strDecimale2);
System.out.println("String to Double: " + decimale2);
} catch (NumberFormatException e) {
System.out.println("Erreur de format : " + e.getMessage());
}
// Conversion des chaînes vers objets enveloppes
String strEntier3 = "42";
Integer entier3 = Integer.valueOf(strEntier3);
System.out.println("String to Integer Object: " + entier3);
String strDecimale3 = "3.14";
Double decimale3 = Double.valueOf(strDecimale3);
System.out.println("String to Double Object: " + decimale3);
}
}
Chaine de type « TEXT BLOCKS » de Java SE
Java SE 15 a déployé une fonctionnalité longuement attendue : les chaînes de type « Text Blocks ». Cette innovation apporte une syntaxe élégante et efficace pour la création et la manipulation de chaînes de texte longues et multilignes en Java.
La démo :
1. Qu’est-ce qu’un Text Block ?
Un Text Block est une façon d’écrire des chaînes de caractères sur plusieurs lignes sans utiliser beaucoup de caractères d’échappement comme \n pour les nouvelles lignes.
2. Exemple classique sans Text Block
Avant l’introduction des Text Blocks, écrire des chaînes de caractères multilignes était compliqué. Voici un exemple d’un morceau de HTML sans utiliser de Text Block :
String html = "<html>\n" +
" <body>\n" +
" <p>Bonjour, monde!</p>\n" +
" </body>\n" +
"</html>";
3. Exemple avec Text Block
Avec les Text Blocks, c’est beaucoup plus simple. Voici le même exemple en utilisant un Text Block :
String html = """
<html>
<body>
<p>Bonjour, monde!</p>
</body>
</html>
""";
4. Avantages des Text Blocks
a. Lisibilité
Les Text Blocks rendent le code plus lisible car vous pouvez écrire le texte exactement comme il apparaît, sans avoir à ajouter des \n pour les nouvelles lignes.
b. Moins de caractères d’échappement
Avec les Text Blocks, vous n’avez pas besoin d’utiliser des caractères d’échappement comme \" pour les guillemets ou \\ pour les barres obliques inverses.
5. Caractéristiques des Text Blocks
a. Préservation de l’indentation
Les Text Blocks conservent l’indentation relative de votre texte, mais ils suppriment l’indentation commune, ce qui signifie que votre texte sera bien formaté.
Exemple :
String json = """
{
"nom": "Exemple",
"valeur": 123
}
""";b. Facilité d’utilisation
Les Text Blocks sont utiles pour écrire du HTML, du JSON, du XML, des messages d’erreur, et plus encore.
6. Méthodes Utiles
a. translateEscapes()
Cette méthode interprète les séquences d’échappement dans un Text Block.
Exemple :
String withEscapes = """
Voici une ligne de texte\\nEt une autre ligne de texte
""".translateEscapes();
b. Interpolation de chaînes dans les Text Blocks
Une autre fonctionnalité utile des chaînes de type « Text Blocks » est l’interpolation de chaînes, qui permet d’incorporer des expressions Java dans le texte. Par exemple :
String name = "John";
String textBlockWithInterpolation = """
Bonjour, %s!
Bienvenue dans le monde des Text Blocks.
""".formatted(name);
Dans cet exemple, %s est une marque de formatage qui sera remplacée par la valeur de la variable name lors de la création de la chaîne.
Bonnes pratiques et Astuces
Les techniques avancées de manipulation des chaînes de caractères en Java vont au-delà des opérations de base et offrent des fonctionnalités plus puissantes pour traiter des scénarios complexes. Dans cette section, nous explorerons l’utilisation de la classe StringBuilder pour une manipulation mutable des chaînes, ainsi que d’autres méthodes avancées pour répondre à des besoins spécifiques.
1. Manipulation Mutable avec StringBuilder :
La classe StringBuilder est souvent utilisée lorsque des opérations de modification fréquentes sont nécessaires sur une chaîne. Contrairement à la classe String, les objets StringBuilder sont modifiables.
Exemple :
StringBuilder builder = new StringBuilder("Programmation");
builder.append(" en Java");
builder.insert(0, "La ");
builder.replace(20, 25, "C++");
System.out.println("Résultat : " + builder.toString());
Explication :
StringBuilder: Crée un objetStringBuilderinitialisé avec « Programmation ».append(" en Java"): Ajoute la chaîne » en Java » à la fin.insert(0, "La "): Insère la chaîne « La » au début.replace(20, 25, "C++"): Remplace la sous-chaîne de la position 20 à 25 par « C++ ».toString(): Convertit leStringBuilderen une chaîne de caractères.- Résultat : La sortie affichera « Résultat : La Programmation en C++ ».
2. Division et Jointure :
Les méthodes split() et join() sont utiles pour diviser une chaîne en plusieurs parties et les rejoindre ultérieurement.
Exemple :
String phrase = "La programmation en Java est intéressante";
String[] mots = phrase.split(" ");
String nouvellePhrase = String.join("-", mots);
System.out.println("Nouvelle phrase : " + nouvellePhrase);
Explication :
split(" "): Divise la phrase en un tableau de mots en utilisant l’espace comme séparateur.String.join("-", mots): Joint les mots en utilisant le trait d’union comme séparateur.- Résultat : La sortie affichera « Nouvelle phrase : La-programmation-en-Java-est-intéressante ».
3. Utilisation de startsWith() et endsWith()
– startsWith() : Vérifier si une Chaîne Commence par une Séquence Donnée :
La méthode startsWith() est utilisée pour déterminer si une chaîne commence par une séquence spécifiée. Voici un exemple :
String texte = "La programmation en Java";
boolean commenceParLa = texte.startsWith("La");
System.out.println("Commence par 'La' : " + commenceParLa);
Explication détaillée :
startsWith("La"): Cette méthode retournetruesi la chaîne commence par la séquence « La », sinon elle retournefalse.- Résultat : La sortie affichera « Commence par ‘La’ : true », car la chaîne commence effectivement par « La ».
– endsWith() : Vérifier si une Chaîne se Termine par une Séquence Donnée :
La méthode endsWith() est utilisée pour déterminer si une chaîne se termine par une séquence spécifiée. Voici un exemple :
String texte = "La programmation en Java";
boolean seTermineParJava = texte.endsWith("Java");
System.out.println("Se termine par 'Java' : " + seTermineParJava);
Explication :
endsWith("Java"): Cette méthode retournetruesi la chaîne se termine par la séquence « Java », sinon elle retournefalse.- Résultat : La sortie affichera « Se termine par ‘Java’ : true », car la chaîne se termine effectivement par « Java ».
Ces méthodes sont utiles pour effectuer des vérifications de préfixe et de suffixe dans des chaînes, ce qui est souvent nécessaire lors du traitement de données textuelles
4. Remplacement Rapide avec replaceFirst() et replaceAll()
Si vous devez remplacer une occurrence spécifique ou toutes les occurrences d’une sous-chaîne, vous pouvez utiliser replaceFirst() et replaceAll().
String phrase = "La pomme est rouge. La pomme est délicieuse.";
String nouvellePhrase1 = phrase.replaceFirst("pomme", "orange");
String nouvellePhrase2 = phrase.replaceAll("pomme", "orange");
System.out.println("ReplaceFirst : " + nouvellePhrase1);
System.out.println("ReplaceAll : " + nouvellePhrase2);
Explication :
replaceFirst("pomme", "orange"): Remplace la première occurrence de « pomme » par « orange ».replaceAll("pomme", "orange"): Remplace toutes les occurrences de « pomme » par « orange ».
5. Utilisation de matches() pour la Correspondance avec une Expression Régulière
La méthode matches() permet de vérifier si une chaîne correspond à une expression régulière.
String email = "utilisateur@example.com";
boolean estEmailValide = email.matches("^[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]{2,})+$");
System.out.println("L'email est valide : " + estEmailValide);
Explication :
matches("^[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]{2,})+$"): Utilise une expression régulière pour vérifier la validité d’un email.- Résultat : La sortie affichera « L’email est valide : true » si l’email respecte le format défini.
6. Utilisation de replace() pour Remplacer Plusieurs Caractères
La méthode replace() peut être utilisée pour remplacer plusieurs caractères en une seule fois.
String texte = "Java est | puissant | et | polyvalent";
String texteModifie = texte.replace("|", "-").replace(" et ", "&");
System.out.println("Texte modifié : " + texteModifie);
Explication :
replace("|", "-").replace(" et ", "&"): Remplace les occurrences de « | » par « – » et » et » par « & » en une seule expression.- Résultat : La sortie affichera « Texte modifié : Java est – puissant – & polyvalent ».
7. Conversion entre String et char[]
Vous pouvez convertir une chaîne en tableau de caractères et vice versa.
Conversion de String vers char[] :
String texte = "Java";
char[] tableauDeCaracteres = texte.toCharArray();
System.out.println("Tableau de caractères : " + Arrays.toString(tableauDeCaracteres));
Conversion de char[] vers String :
char[] tableauDeCaracteres = {'J', 'a', 'v', 'a'};
String texte = new String(tableauDeCaracteres);
System.out.println("Chaîne : " + texte);
8. Utilisation de StringUtils de la bibliothèque Apache Commons Lang
La bibliothèque Apache Commons Lang propose la classe StringUtils qui offre diverses méthodes pour manipuler les chaînes de manière plus avancée.
String texte = "Manipulation avancée avec StringUtils";
String majuscules = StringUtils.upperCase(texte);
String inverse = StringUtils.reverse(texte);
boolean contientVoyelles = StringUtils.containsAny(texte, 'a', 'e', 'i', 'o', 'u');
Explication :
StringUtils.upperCase(texte): Convertit la chaîne en majuscules.StringUtils.reverse(texte): Inverse la chaîne.StringUtils.containsAny(texte, 'a', 'e', 'i', 'o', 'u'): Vérifie si la chaîne contient au moins une voyelle.
9. Utilisation de String::isBlank pour Vérifier si une Chaîne est Vide ou Contient Seulement des Espaces
La méthode isBlank permet de vérifier si une chaîne est vide ou ne contient que des espaces.
String texteVide = "";
String texteAvecEspaces = " ";
System.out.println("Est vide : " + texteVide.isBlank());
System.out.println("Contient seulement des espaces : " + texteAvecEspaces.isBlank());
Explication :
texteVide.isBlank(): Vérifie si la chaîne est vide ou contient uniquement des espaces.texteAvecEspaces.isBlank(): Vérifie si la chaîne contient uniquement des espaces.
10. Utilisation de String::translateEscapes pour Traiter les Échappements Unicode
La méthode translateEscapes permet de traiter les échappements Unicode dans une chaîne.
String texteUnicode = "Hello\\nWorld\\t2024";
String texteTraduit = texteUnicode.translateEscapes();
System.out.println("Texte traduit : " + texteTraduit);
Explication :
texteUnicode.translateEscapes(): Traduit les échappements Unicode dans la chaîne.
Exemples Pratiques et Applications
Exercice 1: Trouver les anagrammes
Écrivez un programme en Java qui prend deux chaînes de caractères en entrée et détermine si ces deux chaînes sont des anagrammes l’une de l’autre. Deux chaînes sont dites anagrammes si elles contiennent exactement les mêmes caractères avec les mêmes fréquences, mais dans un ordre différent.
Exemple :
- Chaîne 1 : « listen »
- Chaîne 2 : « silent »
Sortie attendue : « Les chaînes sont des anagrammes. »
- Chaîne 1 : « hello »
- Chaîne 2 : « world »
Sortie attendue : « Les chaînes ne sont pas des anagrammes. »
Correction
import java.util.Arrays;
public class AnagramChecker {
public static void main(String[] args) {
String str1 = "listen";
String str2 = "silent";
boolean areAnagrams = areAnagrams(str1, str2);
if (areAnagrams) {
System.out.println("Les chaînes sont des anagrammes.");
} else {
System.out.println("Les chaînes ne sont pas des anagrammes.");
}
}
public static boolean areAnagrams(String str1, String str2) {
if (str1.length() != str2.length()) {
return false;
}
char[] charArray1 = str1.toCharArray();
char[] charArray2 = str2.toCharArray();
Arrays.sort(charArray1);
Arrays.sort(charArray2);
return Arrays.equals(charArray1, charArray2);
}
}
- Vérifiez d’abord si les deux chaînes ont la même longueur. Si ce n’est pas le cas, elles ne peuvent pas être des anagrammes.
- Convertissez les chaînes en tableaux de caractères.
- Triez les deux tableaux de caractères.
- Comparez les tableaux triés. S’ils sont identiques, les chaînes sont des anagrammes. Sinon, elles ne le sont pas.
Exercice 2: Compter les Occurrences d’un Caractère dans une Chaîne
Objectif: Écrire une méthode qui compte le nombre d’occurrences d’un caractère spécifié dans une chaîne de caractères donnée.
Correction
solution 1
public class CharacterCounter {
// Méthode pour compter les occurrences d'un caractère dans une chaîne
public static int countOccurrences(String str, char ch) {
int count = 0;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == ch) {
count++;
}
}
return count;
}
// Méthode principale pour tester le comptage des occurrences
public static void main(String[] args) {
String str = "Bonjour le monde";
char ch = 'o';
int occurrences = countOccurrences(str, ch);
System.out.println("Le caractère '" + ch + "' apparaît " + occurrences + " fois dans la chaîne.");
}
}
Explication:
- Nous utilisons une boucle
forpour parcourir chaque caractère de la chaîne. - À chaque itération, nous vérifions si le caractère à l’indice actuel est égal au caractère spécifié.
- Si c’est le cas, nous incrémentons le compteur d’occurrences.
- Enfin, nous retournons le nombre total d’occurrences trouvées.
Cette méthode permet de compter le nombre d’occurrences d’un caractère spécifié dans une chaîne de caractères donnée.
Solution 2 :
import java.util.stream.IntStream;
public class CharacterCounter {
// Méthode pour compter les occurrences d'un caractère dans une chaîne
public static long countOccurrences(String str, char ch) {
return str.chars().filter(c -> c == ch).count();
}
// Méthode principale pour tester le comptage des occurrences
public static void main(String[] args) {
String str = "Bonjour le monde";
char ch = 'o';
long occurrences = countOccurrences(str, ch);
System.out.println("Le caractère '" + ch + "' apparaît " + occurrences + " fois dans la chaîne.");
}
}
Dans cette version, nous utilisons la méthode chars() pour obtenir un flux d’entiers représentant les valeurs ASCII des caractères dans la chaîne. Ensuite, nous utilisons la méthode filter pour filtrer seulement les caractères égaux au caractère spécifié ch, puis nous utilisons count() pour obtenir le nombre total d’occurrences.
Cette méthode est plus concise et exprime plus directement l’intention de compter les occurrences du caractère spécifié dans la chaîne donnée.
Exercice 3 : Vérifier si une Chaîne est un Palindrome
Objectif: Écrire une méthode qui vérifie si une chaîne de caractères donnée est un palindrome, c’est-à-dire si elle se lit de la même manière de gauche à droite et de droite à gauche.
Correction
public class PalindromeChecker {
// Méthode pour vérifier si une chaîne est un palindrome
public static boolean isPalindrome(String str) {
int left = 0;
int right = str.length() - 1;
while (left < right) {
if (str.charAt(left) != str.charAt(right)) {
return false;
}
left++;
right--;
}
return true;
}
// Méthode principale pour tester si une chaîne est un palindrome
public static void main(String[] args) {
String str = "radar";
boolean isPalindrome = isPalindrome(str);
if (isPalindrome) {
System.out.println("La chaîne '" + str + "' est un palindrome.");
} else {
System.out.println("La chaîne '" + str + "' n'est pas un palindrome.");
}
}
}
Explication:
- Nous utilisons deux indices,
leftetright, pour parcourir la chaîne de chaque extrémité. - À chaque itération, nous comparons les caractères à ces indices pour vérifier s’ils sont égaux.
- Si à un moment donné les caractères ne sont pas égaux, la méthode renvoie
falsecar la chaîne n’est pas un palindrome. - Si nous atteignons le milieu de la chaîne sans trouver de caractères différents, la méthode renvoie
truecar la chaîne est un palindrome.
Cette méthode permet de vérifier si une chaîne donnée est un palindrome.
Exercice 4 : Supprimer les Espaces d’une Chaîne de Caractères
Objectif : Écrire une méthode qui prend une chaîne de caractères en entrée et renvoie une nouvelle chaîne dans laquelle tous les espaces ont été supprimés.
Correction
Solution 1 :
public class SpaceRemover {
// Méthode pour supprimer les espaces d'une chaîne de caractères
public static String removeSpaces(String str) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) != ' ') {
result.append(str.charAt(i));
}
}
return result.toString();
}
// Méthode principale pour tester la suppression des espaces
public static void main(String[] args) {
String str = "Hello World";
String result = removeSpaces(str);
System.out.println("Chaîne sans espaces : " + result);
}
}
Explication :
- Nous utilisons un objet
StringBuilderpour construire la nouvelle chaîne sans espaces. - Nous parcourons chaque caractère de la chaîne d’origine à l’aide d’une boucle
for. - Si le caractère actuel n’est pas un espace, nous l’ajoutons à l’objet
StringBuilder. - Enfin, nous retournons la nouvelle chaîne sans espaces à l’aide de la méthode
toString()deStringBuilder.
Cette méthode permet de supprimer tous les espaces d’une chaîne de caractères donnée.
Solution 2 :
voici une autre méthode pour supprimer les espaces d’une chaîne sans utiliser de boucle for, en utilisant les méthodes replace() de la classe String :
public class SpaceRemover {
// Méthode pour supprimer les espaces d'une chaîne de caractères
public static String removeSpaces(String str) {
return str.replace(" ", "");
}
// Méthode principale pour tester la suppression des espaces
public static void main(String[] args) {
String str = "Hello World";
String result = removeSpaces(str);
System.out.println("Chaîne sans espaces : " + result);
}
}
Cette méthode utilise la méthode replace() pour remplacer tous les espaces par une chaîne vide, ce qui a pour effet de supprimer tous les espaces de la chaîne originale.
Exercice 5 : Compter le Nombre de Mots dans une Chaîne
Objectif : Écrire une méthode qui compte le nombre de mots dans une chaîne de caractères donnée. On considère qu’un mot est une séquence de caractères séparée par des espaces.
Correction
public class WordCounter {
// Méthode pour compter le nombre de mots dans une chaîne
public static int countWords(String str) {
// Utilisation de la méthode split() pour diviser la chaîne en mots
String[] words = str.split("\\s+");
return words.length;
}
// Méthode principale pour tester le comptage des mots
public static void main(String[] args) {
String str = "Bonjour le monde";
int wordCount = countWords(str);
System.out.println("Nombre de mots dans la chaîne : " + wordCount);
}
}
Explication :
- Nous utilisons la méthode
split("\\s+")pour diviser la chaîne en mots en utilisant les espaces comme délimiteurs. - Le motif
"\\s+"correspond à un ou plusieurs espaces, ce qui permet de gérer les espaces consécutifs entre les mots. - La méthode
split()retourne un tableau de chaînes de caractères représentant les mots individuels dans la chaîne d’origine. - Nous retournons simplement la longueur de ce tableau, qui correspond au nombre de mots dans la chaîne.
Cette méthode permet de compter le nombre de mots dans une chaîne de caractères donnée.
Quiz de ce tuto
Vous pouvez tester que vous avez bien assimiler tous ce que nous avons appris ensemble via ce quiz 🙂 🙂 amusez vous bien.