streamalism.org

1. Oversigt

Der er mange måder at kontrollere, om en Snor indeholder et underlag. I denne artikel vil vi lede efter understreng i en Snor mens du fokuserer på store og små bogstaver til String.contains () i Java. Vigtigst er det, at vi giver eksempler på, hvordan du løser dette problem.

2. Den enkleste løsning: String.toLowerCase

Den enkleste løsning er ved hjælp af String.toLowerCase (). I dette tilfælde transformerer vi begge strenge til små bogstaver og bruger derefter indeholder() metode:

assertTrue (src.toLowerCase (). indeholder (dest.toLowerCase ()));

Vi kan også bruge String.toUpperCase () og det ville give det samme resultat.

3. String.matches Med regulære udtryk

En anden mulighed er at bruge String.matches () med regulære udtryk:

assertTrue (src.matches ("(? i). *" + dest + ". *"));

Det Tændstikker() metode tager en String at repræsentere det regulære udtryk. (?jeg) muliggør tilfælde-ufølsomhed og .* bruger hvert tegn undtagen linjeskift.

4. String.regionMatches

Vi kan også bruge String.regionMatches (). Det kontrollerer, om to Snor regioner matcher ved hjælp af rigtigt til ignorere sag parameter:

offentlig statisk boolsk procesRegionMatches (String src, String dest) {for (int i = src.length () - dest.length (); i> = 0; i--) if (src.regionMatches (true, i, dest, 0, dest.length ())) return sand; returner falsk; }

assertTrue (processRegionMatches (src, dest));

For at forbedre ydeevnen begynder det at matche regionen under hensyntagen til destinationens længde Snor. Derefter mindsker det iteratoren.

5. Mønster Med CASE_INSENSITIVE Mulighed

Det java.util.regex.Mønster klasse giver os en måde at matche strenge ved hjælp af matcher () metode. I dette tilfælde kan vi bruge citere() metode til at undslippe eventuelle specialtegn, og CASE_INSENSITIVE flag. Lad os se:

assertTrue (Pattern.compile (Pattern.quote (dest), Pattern.CASE_INSENSITIVE) .matcher (src) .find ());

6. Apache Commons StringUtils.containsIgnoreCase

Endelig drager vi fordel af Apache Commons StringUtils klasse:

assertTrue (StringUtils.containsIgnoreCase (src, dest));

7. Ydeevnesammenligning

Som i denne generelle artikel om kontrol af underlag ved hjælp af indeholder metode brugte vi open source-rammen Java Microbenchmark Harness (JMH) til sammenligne ydeevnen for metoderne i nanosekunder:

1. Mønster CASE_INSENSITIVE Regular Expression: 399,387 ns
2. String toLowerCase: 434,064 ns
3. Apache Commons StringUtils: 496,313 ns
4. String Region Matches: 718,842 ns
5. String matches med Regular Expression: 3964.346 ns

Som vi kan se, er vinderen det Mønster med CASE_INSENSITIVE flag aktiveret, tæt efterfulgt af toLowerCase (). Vi bemærkede også en klar forbedring i ydeevnen mellem Java 8 og Java 11.

8. Konklusion

I denne vejledning så vi på et par forskellige måder at kontrollere en Snor til en substring, mens du ignorerer sagen i Java.

Vi kiggede på at bruge String.toLowerCase () og toUpperCase (), String.matches (), String.regionMatches (), Apache Commons StringUtils.containsIgnoreCase ()og Pattern.matcher (). Find ().

Vi vurderede også ydeevnen for hver løsning og fandt ud af, at vi brugte udarbejde() metode fra java.util.regex.Mønster med CASE_INSENSITIVE flag klarede sig bedst.

Som altid er koden tilgængelig på GitHub.