streamalism.org

1. Oversikt

Det er mange måter å sjekke om en String inneholder et underlag. I denne artikkelen vil vi lete etter underlag i en String mens du fokuserer på store og små bokstaver til String.contains () i Java. Viktigst, vi gir eksempler på hvordan du løser dette problemet.

2. Den enkleste løsningen: String.toLowerCase

Den enkleste løsningen er ved å bruke String.toLowerCase (). I dette tilfellet transformerer vi begge strengene til små bokstaver og bruker deretter inneholder () metode:

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

Vi kan også bruke String.toUpperCase () og det ville gi det samme resultatet.

3. String.matches Med vanlige uttrykk

Et annet alternativ er å bruke String.matches () med vanlige uttrykk:

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

De fyrstikker() metoden tar en String å representere det regulære uttrykket. (?Jeg) muliggjør store og små bokstaver og .* bruker alle tegn unntatt linjeskift.

4. String.regionMatches

Vi kan også bruke String.regionMatches (). Det sjekker om to String regioner samsvarer med, bruker ekte for ignorere tilfelle parameter:

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

assertTrue (processRegionMatches (src, dest));

For å forbedre ytelsen begynner den å matche regionen, med tanke på lengden på destinasjonen String. Deretter reduserer det iteratoren.

5. Mønster Med CASE_INSENSITIVE Alternativ

De java.util.regex.Mønster klasse gir oss en måte å matche strenger på matcher () metode. I dette tilfellet kan vi bruke sitat() metode for å unnslippe spesielle tegn, og CASE_INSENSITIVE flagg. La oss ta en titt:

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

6. Apache Commons StringUtils.containsIgnoreCase

Til slutt vil vi dra nytte av Apache Commons StringUtils klasse:

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

7. Sammenligning av ytelse

Som i denne generelle artikkelen om å se etter underlag ved hjelp av inneholder metode, brukte vi open source-rammeverket Java Microbenchmark Harness (JMH) til sammenligne ytelsen til metodene i nanosekunder:

1. Mønster CASE_INSENSITIVE Regulært uttrykk: 399.387 ns
2. String toLowerCase: 434.064 ns
3. Apache Commons StringUtils: 496.313 ns
4. String Region Matches: 718.842 ns
5. Strengkamper med Regular Expression: 3964.346 ns

Som vi kan se, er vinneren det Mønster med CASE_INSENSITIVE flagg aktivert, tett fulgt av toLowerCase (). Vi la også merke til en klar forbedring i ytelsen mellom Java 8 og Java 11.

8. Konklusjon

I denne opplæringen så vi på noen forskjellige måter å sjekke a på String for en substring, mens du ignorerer saken i Java.

Vi så på å bruke String.toLowerCase () og toUpperCase (), String.matches (), String.regionMatches (), Apache Commons StringUtils.containsIgnoreCase (), og Mønster. Matcher (). Finn ().

Vi evaluerte også ytelsen til hver løsning og fant ut at ved hjelp av kompilere() metode fra java.util.regex.Mønster med CASE_INSENSITIVE flagget presterte best.

Som alltid er koden tilgjengelig på GitHub.