Supprimer ou remplacer une partie d'une chaîne en Java

1. Vue d'ensemble

Dans ce didacticiel, nous allons examiner divers moyens de supprimer ou de remplacer une partie d'une chaîne en Java.

Nous explorerons la suppression et / ou le remplacement d'une sous-chaîne à l'aide d'une API String , puis en utilisant une API StringBuilder et enfin en utilisant la classe StringUtils de la bibliothèque Apache Commons.

En prime, nous examinerons également le remplacement d'un mot exact à l'aide de l'API String et de la classe Apache Commons RegExUtils .

2. API de chaîne

L'une des méthodes les plus simples et les plus directes de remplacement d'une sous-chaîne consiste à utiliser la classe replace, replaceAll ou replaceFirst d'une classe String.

La méthode replace () prend deux arguments - texte cible et texte de remplacement:

String master = "Hello World Baeldung!"; String target = "Baeldung"; String replacement = "Java"; String processed = master.replace(target, replacement); assertTrue(processed.contains(replacement)); assertFalse(processed.contains(target));

L'extrait de code ci-dessus donnera cette sortie:

Hello World Java!

Si une expression régulière est requise pour choisir la cible, alors replaceAll () ou replaceFirst () doit être la méthode de choix. Comme leur nom l'indique, replaceAll () remplacera chaque occurrence correspondante, tandis que replaceFirst () remplacera la première occurrence correspondante:

String master2 = "Welcome to Baeldung, Hello World Baeldung"; String regexTarget = "(Baeldung)$"; String processed2 = master2.replaceAll(regexTarget, replacement); assertTrue(processed2.endsWith("Java"));

La valeur de traité2 sera:

Welcome to Baeldung, Hello World Java

C'est parce que l'expression régulière fournie en tant que regexTarget ne correspondra qu'à la dernière occurrence de Baeldung. Dans tous les exemples donnés ci-dessus, nous pouvons utiliser un remplacement vide et cela supprimera efficacement une cible d'un maître .

3. API StringBuilder

Nous pouvons également manipuler du texte en Java à l'aide de la classe StringBuilder . Les deux méthodes ici sont delete () et replace () .

Nous pouvons construire une instance d'un StringBuilder à partir d'une String existante , puis utiliser les méthodes mentionnées pour effectuer la manipulation de String comme souhaité:

String master = "Hello World Baeldung!"; String target = "Baeldung"; String replacement = "Java"; int startIndex = master.indexOf(target); int stopIndex = startIndex + target.length(); StringBuilder builder = new StringBuilder(master);

Maintenant, nous pouvons supprimer la cible avec le delete () :

builder.delete(startIndex, stopIndex); assertFalse(builder.toString().contains(target));

Nous pouvons également utiliser replace () pour mettre à jour le master:

builder.replace(startIndex, stopIndex, replacement); assertTrue(builder.toString().contains(replacement));

Une différence apparente entre l'utilisation de StringBuilder et de l' API String est que nous devons obtenir nous-mêmes l' index de début et de fin de la chaîne cible .

4. Classe StringUtils

Une autre méthode que nous considérerons est la bibliothèque Apache Commons.

Tout d'abord, ajoutons la dépendance requise à notre projet:

 org.apache.commons commons-lang3 3.8.1 

La dernière version de la bibliothèque est disponible ici.

La classe StringUtils a des méthodes pour remplacer une sous-chaîne d'un String :

String master = "Hello World Baeldung!"; String target = "Baeldung"; String replacement = "Java"; String processed = StringUtils.replace(master, target, replacement); assertTrue(processed.contains(replacement));

Il existe une variante surchargée de replace () qui prend un paramètre max entier , qui détermine le nombre d'occurrences à remplacer. Nous pouvons également utiliser replaceIgnoreCase () si le respect de la casse n'est pas un problème :

String master2 = "Hello World Baeldung!"; String target2 = "baeldung"; String processed2 = StringUtils.replaceIgnoreCase(master2, target2, replacement); assertFalse(processed2.contains(target));

5. Remplacement de mots exacts

Dans ce dernier exemple, nous allons apprendre à remplacer un mot exact dans une chaîne .

Le moyen le plus simple d'effectuer ce remplacement consiste à utiliser une expression régulière avec des limites de mots.

L'expression régulière de limite de mot est \ b . Le fait d'insérer le mot souhaité dans cette expression régulière ne correspondra qu'aux occurrences exactes.

Voyons d'abord comment utiliser cette expression régulière avec l'API String:

String sentence = "A car is not the same as a carriage, and some planes can carry cars inside them!"; String regexTarget = "\\bcar\\b"; String exactWordReplaced = sentence.replaceAll(regexTarget, "truck");

La chaîne exactWordReplaced contient:

"A truck is not the same as a carriage, and some planes can carry cars inside them!"

Seul le mot exact sera remplacé. Remarquez que la barre oblique inverse doit toujours être échappée lorsque vous travaillez avec des expressions régulières en Java.

Une autre façon de faire ce remplacement consiste à utiliser la classe RegExUtils de la bibliothèque Apache Commons, qui peut être ajoutée en tant que dépendance comme nous l'avons vu dans la section précédente:

String regexTarget = "\\bcar\\b"; String exactWordReplaced = RegExUtils.replaceAll(sentence, regexTarget, "truck"); 

Bien que les deux méthodes donnent le même résultat, le choix de celle qui doit être utilisée dépendra de notre scénario spécifique.

6. Conclusion

En conclusion, nous avons exploré plus d'une manière de supprimer et de remplacer une sous-chaîne en Java. La meilleure méthode à appliquer dépend encore largement de la situation et du contexte actuels.

Comme d'habitude, le code source complet est disponible sur Github.