Hoofdletterongevoelige tekenreeksovereenkomst in Java

1. Overzicht

Er zijn veel manieren om te controleren of een Draad bevat een substring. In dit artikel gaan we op zoek naar substrings binnen een Draad terwijl u zich concentreert op hoofdletterongevoelige oplossingen voor String.contains () in Java. Het belangrijkste is dat we voorbeelden geven van hoe u dit probleem kunt oplossen.

2. De eenvoudigste oplossing: String.toLowerCase

De eenvoudigste oplossing is door te gebruiken String.toLowerCase (). In dit geval transformeren we beide strings naar kleine letters en gebruiken we vervolgens de bevat () methode:

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

We kunnen ook gebruik maken van String.toUpperCase () en het zou hetzelfde resultaat opleveren.

3. String.matches Met reguliere expressies

Een andere optie is door gebruik te maken van String.matches () met reguliere expressies:

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

De wedstrijden() methode duurt een String om de reguliere expressie weer te geven. (?ik) maakt het mogelijk ongevoeligheid voor hoofdletters en .* gebruikt elk teken behalve regeleinden.

4. String.regionMatches

We kunnen ook gebruik maken van String.regionMatches (). Het controleert of er twee zijn Draad regio's komen overeen, met behulp van waar voor de negeer zaak parameter:

openbare statische boolean processRegionMatches (String src, String dest) {for (int i = src.length () - dest.length (); i> = 0; i--) if (src.regionMatches (true, i, dest, 0, dest.length ())) retourneert true; teruggeven false; }
assertTrue (processRegionMatches (src, dest));

Om de prestaties te verbeteren, begint het met het matchen van de regio, rekening houdend met de lengte van de bestemming Draad. Vervolgens wordt de iterator verkleind.

5. Patroon Met de CASE_INSENSITIVE Keuze

De java.util.regex.Pattern class biedt ons een manier om strings te matchen met behulp van de matcher () methode. In dit geval kunnen we de citaat() methode om te ontsnappen aan speciale tekens, en de CASE_INSENSITIVE vlag. Laten we kijken:

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

6. Apache Commons StringUtils.containsIgnoreCase

Ten slotte zullen we profiteren van de Apache Commons StringUtils klasse:

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

7. Prestatievergelijking

Zoals in dit algemene artikel over het controleren op subtekenreeksen met de bevat methode, gebruikten we het open-source framework Java Microbenchmark Harness (JMH) om vergelijk de prestaties van de methoden in nanoseconden:

  1. Patroon CASE_INSENSITIVE Reguliere expressie: 399.387 ns
  2. String toLowerCase: 434.064 ns
  3. Apache Commons StringUtils: 496.313 ns
  4. Tekenreeksregioovereenkomsten: 718.842 ns
  5. String komt overeen met reguliere expressie: 3964.346 ns

Zoals we kunnen zien, is de winnaar Patroon met de CASE_INSENSITIVE vlag ingeschakeld, op de voet gevolgd door toLowerCase (). We merkten ook een duidelijke verbetering in de prestaties tussen Java 8 en Java 11.

8. Conclusie

In deze tutorial hebben we een paar verschillende manieren bekeken om een Draad voor een substring, terwijl het hoofdlettergebruik in Java wordt genegeerd.

We hebben gekeken naar het gebruik van String.toLowerCase () en toUpperCase (), String.matches (), String.regionMatches (), Apache Commons StringUtils.containsIgnoreCase (), en Pattern.matcher (). Find ().

We hebben ook de prestaties van elke oplossing geëvalueerd en vastgesteld dat het compileren() methode van java.util.regex.Pattern met de CASE_INSENSITIVE flag presteerde het beste.

Zoals altijd is de code beschikbaar op GitHub.