Java >> Java tutorial >  >> Tag >> native

L-Trim og R-Trim alternativer i Java

1. Oversigt

Metoden String.trim() fjerner bagende og førende mellemrum. Men der er ingen støtte til bare at lave en L-Trim eller R-Trim.

I denne tutorial vil vi se et par måder, vi kan implementere dette på; til sidst vil vi sammenligne deres præstationer.

2. mens Løkke

Den enkleste løsning er at gå gennem strengen ved hjælp af et par mens sløjfer.

For L-Trim læser vi strengen fra venstre mod højre, indtil vi støder ind i et tegn uden mellemrum:

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

ltrim er så en understreng, der starter ved det første ikke-mellemrumstegn.

Eller for R-Trim læser vi vores streng fra højre mod venstre, indtil vi støder på et tegn uden mellemrum:

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

rtrim er så en understreng, der starter i begyndelsen og slutter ved det første ikke-mellemrumstegn.

3. String.replaceAll Brug af regulære udtryk

En anden mulighed er at bruge String.replaceAll() og et regulært udtryk:

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

(\\s+) er det regex, der matcher et eller mange mellemrumstegn. Indtrykket (^) og ($) i begyndelsen og slutningen af ​​det regulære udtryk matcher begyndelsen og slutningen af ​​en linje.

4. Pattern.compile() og .matcher()

Vi kan genbruge regulære udtryk med java.util.regex.Pattern også:

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

Derudover kan vi drage fordel af Apache Commons StringUtils#stripStart og #stripEnd metoder til at fjerne mellemrum.

Til det, lad os først tilføje commons-lang3 afhængighed:

<dependency> 
    <groupId>org.apache.commons</groupId> 
    <artifactId>commons-lang3</artifactId> 
    <version>3.12.0</version> 
</dependency>

Efter dokumentationen bruger vi null for at fjerne mellemrummet:

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

6. Guava

Endelig vil vi drage fordel af Guava CharMatcher#trimLeadingFrom og #trimTrailingFrom metoder til at opnå det samme resultat.

Igen, lad os tilføje den passende Maven-afhængighed, denne gang dens guava :

<dependency> 
    <groupId>com.google.guava</groupId> 
    <artifactId>guava</artifactId> 
    <version>31.0.1-jre</version> 
</dependency>

Og i Guava ligner det meget, hvordan det gøres i Apache Commons, bare med mere målrettede metoder:

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

7. Præstationssammenligning

Lad os se metodernes ydeevne. Som sædvanlig vil vi gøre brug af open source-rammeværket Java Microbenchmark Harness (JMH) til at sammenligne de forskellige alternativer på nanosekunder.

7.1. Benchmark-opsætning

Til den indledende konfiguration af benchmark har vi brugt fem gafler og gennemsnitlige tidsberegningstider i nanosekunder:

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

I opsætningsmetoden initialiserer vi det originale meddelelsesfelt og den resulterende streng for at sammenligne med:

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

Alle benchmarks fjerner først det venstre mellemrum, fjerner derefter det højre mellemrum og sammenligner til sidst resultaterne med deres forventede strenge.

7.2. mens Løkke

For vores første benchmark, lad os bruge mens loop tilgang:

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

7.3. String.replaceAll()  med regulært udtryk

Så lad os prøve 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()

Derefter kommer Pattern.compile().matches() :

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

7.5. Apache Commons

For det fjerde, Apache Commons:

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

7.6. Guava

Og endelig, lad os bruge Guava:

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

7.7. Analyse af resultaterne

Og vi skulle få nogle resultater, der ligner følgende:

# 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

Og det ser ud til, at vores vindere er mens loop, Apache Commons og Guava!

8. Konklusion

I dette selvstudie har vi set på et par forskellige måder at fjerne mellemrumstegn i begyndelsen og slutningen af ​​en streng .

Vi brugte mens loop, String.replaceAll(), Pattern.matcher().replaceAll(), Apache Commons og Guava for at opnå dette resultat.

Som altid er koden tilgængelig på GitHub.


Java tag