Supprimer les caractères de début et de fin d'une chaîne

1. Introduction

Dans ce court didacticiel, nous verrons plusieurs façons de supprimer les caractères de début et de fin d'une chaîne . Par souci de simplicité, nous supprimerons les zéros dans les exemples.

Avec chaque implémentation, nous allons créer deux méthodes: une pour les zéros de début et une pour les zéros de fin.

Ce problème a un cas de bord: que voulons-nous faire, lorsque l'entrée ne contient que des zéros? Renvoyer une chaîne vide ou une chaîne contenant un seul zéro? Nous verrons des implémentations pour les deux cas d'utilisation dans chacune des solutions.

Nous avons des tests unitaires pour chaque implémentation, que vous pouvez trouver sur GitHub.

2. Utilisation de StringBuilder

Dans notre première solution, nous allons créer un StringBuilder avec la chaîne d' origine , et nous supprimerons les caractères inutiles du début ou de la fin:

String removeLeadingZeroes(String s) { StringBuilder sb = new StringBuilder(s); while (sb.length() > 0 && sb.charAt(0) == '0') { sb.deleteCharAt(0); } return sb.toString(); } String removeTrailingZeroes(String s) { StringBuilder sb = new StringBuilder(s); while (sb.length() > 0 && sb.charAt(sb.length() - 1) == '0') { sb.setLength(sb.length() - 1); } return sb.toString(); }

Notez que nous utilisons StringBuilder.setLength () au lieu de StringBuilder.deleteCharAt () lorsque nous supprimons les zéros de fin car il supprime également les derniers caractères et il est plus performant.

Si nous ne voulons pas renvoyer une chaîne vide lorsque l'entrée ne contient que des zéros, la seule chose que nous devons faire est d' arrêter la boucle s'il ne reste qu'un seul caractère .

Par conséquent, nous modifions la condition de la boucle:

String removeLeadingZeroes(String s) { StringBuilder sb = new StringBuilder(s); while (sb.length() > 1 && sb.charAt(0) == '0') { sb.deleteCharAt(0); } return sb.toString(); } String removeTrailingZeroes(String s) { StringBuilder sb = new StringBuilder(s); while (sb.length() > 1 && sb.charAt(sb.length() - 1) == '0') { sb.setLength(sb.length() - 1); } return sb.toString(); }

3. Utilisation de String.subString ()

Dans cette solution, lorsque nous supprimons les zéros de début ou de fin, nous trouvons la position du premier ou du dernier caractère différent de zéro.

Après cela, il suffit d'appeler substring () , pour renvoyer les parties restantes:

String removeLeadingZeroes(String s) { int index; for (index = 0; index = 0; index--) { if (s.charAt(index) != '0') { break; } } return s.substring(0, index + 1); }

Notez que nous devons déclarer la variable index avant la boucle for car nous voulons utiliser la variable en dehors de la portée de la boucle.

Notez également que nous devons rechercher manuellement les caractères non nuls, car String.indexOf () et String.lastIndexOf () ne fonctionnent que pour une correspondance exacte.

Si nous ne voulons pas renvoyer une chaîne vide , nous devons faire la même chose que précédemment: changer la condition de la boucle :

String removeLeadingZeroes(String s) { int index; for (index = 0; index  0; index--) { if (s.charAt(index) != '0') { break; } } return s.substring(0, index + 1); }

4. Utilisation d'Apache Commons

Apache Commons possède de nombreuses classes utiles, notamment org.apache.commons.lang.StringUtils . Pour être plus précis, cette classe est dans Apache Commons Lang3.

4.1. Dépendances

Nous pouvons utiliser Apache Commons Lang3 en insérant cette dépendance dans notre fichier pom.xml :

 org.apache.commons commons-lang3 3.8.1 

4.2. la mise en oeuvre

Dans la classe StringUtils , nous avons les méthodes stripStart () et stripEnd () . Ils suppriment respectivement les caractères de début et de fin.

Comme c'est exactement ce dont nous avons besoin, notre solution est assez simple:

String removeLeadingZeroes(String s) { return StringUtils.stripStart(s, "0"); } String removeTrailingZeroes(String s) { return StringUtils.stripEnd(s, "0"); }

Malheureusement, nous ne pouvons pas configurer, si nous voulons supprimer toutes les occurrences ou non. Par conséquent, nous devons le contrôler manuellement.

Si l'entrée n'était pas vide, mais que la chaîne supprimée est vide, nous devons retourner exactement un zéro:

String removeLeadingZeroes(String s) { String stripped = StringUtils.stripStart(s, "0"); if (stripped.isEmpty() && !s.isEmpty()) { return "0"; } return stripped; } String removeTrailingZeroes(String s) { String stripped = StringUtils.stripEnd(s, "0"); if (stripped.isEmpty() && !s.isEmpty()) { return "0"; } return stripped; }

Notez que ces méthodes acceptent une chaîne comme deuxième paramètre. Cette chaîne représente un ensemble de caractères, pas une séquence que nous voulons supprimer.

Par exemple, si nous passons «01» , ils supprimeront tous les caractères de début ou de fin, qui sont soit «0» ou «1» .

5. Utilisation de la goyave

Guava fournit également de nombreuses classes d'utilité. Pour ce problème, nous pouvons utiliser com.google.common.base.CharMatcher , qui fournit des méthodes utilitaires pour interagir avec les caractères correspondants.

5.1. Dépendances

Pour utiliser Guava, nous devons ajouter les dépendances suivantes à notre fichier pom.xml :

 com.google.guava guava 27.0.1-jre 

Notez que si nous voulons utiliser Guava dans une application Android, nous devrions utiliser la version 27.0-android à la place.

5.2. la mise en oeuvre

Dans notre cas, nous sommes intéressés par trimLeadingFrom () et trimTrailingFrom () .

Comme leur nom l'indique, ils suppriment respectivement tout caractère de début ou de fin d'une chaîne , qui correspond au CharMatcher :

String removeLeadingZeroes(String s) { return CharMatcher.is('0').trimLeadingFrom(s); } String removeTrailingZeroes(String s) { return CharMatcher.is('0').trimTrailingFrom(s); }

Ils ont les mêmes caractéristiques que les méthodes Apache Commons que nous avons vues.

Par conséquent, si nous ne voulons pas supprimer tous les zéros, nous pouvons utiliser la même astuce:

String removeLeadingZeroes(String s) { String stripped = CharMatcher.is('0').trimLeadingFrom(s); if (stripped.isEmpty() && !s.isEmpty()) { return "0"; } return stripped; } String removeTrailingZeroes(String s) { String stripped = CharMatcher.is('0').trimTrailingFrom(s); if (stripped.isEmpty() && !s.isEmpty()) { return "0"; } return stripped; }

Notez qu'avec CharMatcher, nous pouvons créer des règles de correspondance plus complexes.

6. Utilisation d'expressions régulières

Puisque notre problème est un problème de correspondance de modèle, nous pouvons utiliser des expressions régulières: nous voulons faire correspondre tous les zéros au début ou à la fin d'une chaîne .

En plus de cela, nous voulons supprimer les zéros correspondants. En d'autres termes, nous voulons les remplacer par rien, ou en d'autres termes, une chaîne vide .

Nous pouvons faire exactement cela, avec la méthode String.replaceAll () :

String removeLeadingZeroes(String s) { return s.replaceAll("^0+", ""); } String removeTrailingZeroes(String s) { return s.replaceAll("0+$", ""); }

Si nous ne voulons pas supprimer tous les zéros, nous pourrions utiliser la même solution que celle que nous avons utilisée avec Apache Commons et Guava. Cependant, il existe une manière pure d'expression régulière de faire cela: nous devons fournir un modèle, qui ne correspond pas à la chaîne entière .

De cette façon, si l'entrée ne contient que des zéros, le moteur d'expression régulière en gardera exactement un hors de la correspondance. Nous pouvons le faire avec les modèles suivants:

String removeLeadingZeroes(String s) { return s.replaceAll("^0+(?!$)", ""); } String removeTrailingZeroes(String s) { return s.replaceAll("(?!^)0+$", ""); }

Notez que «(?! ^)» Et «(?! $)» Signifient que ce n'est pas respectivement le début ou la fin de la chaîne .

7. Conclusion

Dans ce didacticiel, nous avons vu plusieurs façons de supprimer les caractères de début et de fin d'une chaîne . Le choix entre ces implémentations est souvent simplement une préférence personnelle.

Comme d'habitude, les exemples sont disponibles à l'adresse over sur GitHub.