Alternatives L-Trim et R-Trim en Java

1. Vue d'ensemble

La méthode String.trim () supprime les espaces de fin et de début. Mais, il n'y a pas de support pour simplement faire un L-Trim ou R-Trim.

Dans ce didacticiel, nous verrons quelques façons de l'implémenter; à la fin, nous comparerons leurs performances.

2. boucle while

La solution la plus simple consiste à parcourir la chaîne en utilisant quelques boucles while .

Pour L-Trim, nous lirons la chaîne de gauche à droite jusqu'à ce que nous rencontrions un caractère sans espace:

int i = 0; while (i < s.length() && Character.isWhitespace(s.charAt(i))) { i++; } String ltrim = s.substring(i); 

ltrim est alors une sous-chaîne commençant au premier caractère non blanc.

Ou pour R-Trim, nous lirons notre chaîne de droite à gauche jusqu'à ce que nous rencontrions un caractère non blanc:

int i = s.length()-1; while (i >= 0 && Character.isWhitespace(s.charAt(i))) { i--; } String rtrim = s.substring(0,i+1);

rtrim est alors une sous-chaîne commençant au début et se terminant au premier caractère non blanc.

3. String.replaceAll utilisant des expressions régulières

Une autre option consiste à utiliser String.replaceAll () et une expression régulière:

String ltrim = src.replaceAll("^\\s+", ""); String rtrim = src.replaceAll("\\s+$", "");

(\\ s +) est l'expression régulière qui correspond à un ou plusieurs caractères d'espacement. Le signe d'insertion (^) et le ($) au début et à la fin de l'expression régulière correspondent au début et à la fin d'une ligne.

4. Pattern.compile () et .matcher ()

Nous pouvons également réutiliser des expressions régulières avec java.util.regex.Pattern :

private static Pattern LTRIM = Pattern.compile("^\\s+"); private static Pattern RTRIM = Pattern.compile("\\s+$"); String ltrim = LTRIM.matcher(s).replaceAll(""); String rtim = RTRIM.matcher(s).replaceAll("");

5. Apache Commons

De plus, nous pouvons tirer parti des méthodes Apache Commons StringUtils # stripStart et #stripEnd pour supprimer les espaces.

Pour cela, ajoutons d'abord la dépendance commons-lang3 :

 org.apache.commons commons-lang3 3.8.1 

Suite à la documentation, nous utilisons null afin de supprimer les espaces:

String ltrim = StringUtils.stripStart(src, null); String rtrim = StringUtils.stripEnd(src, null);

6. Goyave

Enfin, nous allons profiter des méthodes Guava CharMatcher # trimLeadingFrom et #trimTrailingFrom pour obtenir le même résultat.

Encore une fois, ajoutons la dépendance Maven appropriée, cette fois sa goyave :

 com.google.guava guava 28.2-jre 

Et dans Guava, c'est assez similaire à la façon dont c'est fait dans Apache Commons, juste avec des méthodes plus ciblées:

String ltrim = CharMatcher.whitespace().trimLeadingFrom(s); String rtrim = CharMatcher.whitespace().trimTrailingFrom(s);

7. Comparaison des performances

Voyons les performances des méthodes. Comme d'habitude, nous utiliserons le framework open-source Java Microbenchmark Harness (JMH) pour comparer les différentes alternatives en nanosecondes.

7.1. Configuration de référence

Pour la configuration initiale du benchmark, nous avons utilisé cinq fourchettes et des temps de calcul du temps moyen en nanosecondes:

@Fork(5) @State(Scope.Benchmark) @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.NANOSECONDS)

Dans la méthode de configuration, nous initialisons le champ de message d'origine et la chaîne résultante à comparer avec:

@Setup public void setup() { src = " White spaces left and right "; ltrimResult = "White spaces left and right "; rtrimResult = " White spaces left and right"; }

Tous les benchmarks suppriment d'abord l'espace blanc gauche, puis suppriment l'espace blanc droit, et enfin comparent les résultats à leurs chaînes attendues.

7.2. while Loop

Pour notre première référence, nous allons utiliser la tout approche en boucle:

@Benchmark public boolean whileCharacters() { String ltrim = whileLtrim(src); String rtrim = whileRtrim(src); return checkStrings(ltrim, rtrim); }

7.3. String.replaceAll () avec expression régulière

Ensuite, essayons String.replaceAll () :

@Benchmark public boolean replaceAllRegularExpression() { String ltrim = src.replaceAll("^\\s+", ""); String rtrim = src.replaceAll("\\s+$", ""); return checkStrings(ltrim, rtrim); }

7.4. Pattern.compile (). Matches ()

Après cela vient Pattern.compile (). Matches () :

@Benchmark public boolean patternMatchesLTtrimRTrim() { String ltrim = patternLtrim(src); String rtrim = patternRtrim(src); return checkStrings(ltrim, rtrim); }

7.5. Apache Commons

Quatrièmement, Apache Commons:

@Benchmark public boolean apacheCommonsStringUtils() { String ltrim = StringUtils.stripStart(src, " "); String rtrim = StringUtils.stripEnd(src, " "); return checkStrings(ltrim, rtrim); }

7.6. Goyave

Et enfin, utilisons Guava:

@Benchmark public boolean guavaCharMatcher() { String ltrim = CharMatcher.whitespace().trimLeadingFrom(src); String rtrim = CharMatcher.whitespace().trimTrailingFrom(src); return checkStrings(ltrim, rtrim); }

7.7. Analyse des résultats

Et nous devrions obtenir des résultats similaires aux suivants:

# Run complete. Total time: 00:16:57 Benchmark Mode Cnt Score Error Units LTrimRTrim.apacheCommonsStringUtils avgt 100 108,718 ± 4,503 ns/op LTrimRTrim.guavaCharMatcher avgt 100 113,601 ± 5,563 ns/op LTrimRTrim.patternMatchesLTtrimRTrim avgt 100 850,085 ± 17,578 ns/op LTrimRTrim.replaceAllRegularExpression avgt 100 1046,660 ± 7,151 ns/op LTrimRTrim.whileCharacters avgt 100 110,379 ± 1,032 ns/op

Et il semble que nos gagnants sont en boucle, Apache Commons, et goyave!

8. Conclusion

Dans ce didacticiel, nous avons examiné différentes façons de supprimer les espaces au début et à la fin d'une chaîne .

Nous avons utilisé while loop, String.replaceAll (), Pattern.matcher (). ReplaceAll (), Apache Commons et Guava pour obtenir ce résultat.

Comme toujours, le code est disponible sur sur GitHub.