String-Matching ohne Berücksichtigung der Groß- und Kleinschreibung in Java

1. Übersicht

Es gibt viele Möglichkeiten zu überprüfen, ob ein String einen Teilstring enthält. In diesem Artikel werden wir für Substrings innerhalb eines suchen String , während auf Groß- und Kleinschreibung Abhilfen zu konzentrieren String.contains () in Java. Am wichtigsten ist, dass wir Beispiele zur Lösung dieses Problems bereitstellen.

2. Die einfachste Lösung: String.toLowerCase

Die einfachste Lösung ist die Verwendung von String.toLowerCase () . In diesem Fall wandeln wir beide Zeichenfolgen in Kleinbuchstaben um und verwenden dann die Methode includes () :

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

Wir können auch String.toUpperCase () verwenden und es würde das gleiche Ergebnis liefern.

3. String.matches mit regulären Ausdrücken

Eine andere Option ist die Verwendung von String.matches () mit regulären Ausdrücken:

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

Die Methode match () verwendet einen S tring , um den regulären Ausdruck darzustellen. (? i) aktiviert die Groß- und Kleinschreibung und . * verwendet alle Zeichen außer Zeilenumbrüchen.

4. String.regionMatches

Wir können auch String.regionMatches () verwenden . Es prüft, ob zwei String- Regionen übereinstimmen, und verwendet true für den Parameter ignoreCase :

public static 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())) return true; return false; }
assertTrue(processRegionMatches(src, dest));

Um die Leistung zu verbessern, wird die Region unter Berücksichtigung der Länge der Zielzeichenfolge abgeglichen . Dann wird der Iterator verkleinert.

5. Muster mit der Option CASE_INSENSITIVE

Die Klasse java.util.regex.Pattern bietet uns eine Möglichkeit, Zeichenfolgen mithilfe der matcher () -Methode abzugleichen . In diesem Fall können wir die quote () -Methode verwenden, um Sonderzeichen und das CASE_INSENSITIVE- Flag zu maskieren . Lass uns einen Blick darauf werfen:

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

6. Apache Commons StringUtils.containsIgnoreCase

Schließlich werden wir die Apache Commons StringUtils- Klasse nutzen:

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

7. Leistungsvergleich

Wie in diesem allgemeinen Artikel über für Teil Überprüfung der Verwendung enthält Methode verwenden wir die Open-Source - Framework Java - Micro Harness (JMH) auf die Durchführung der Verfahren in Nanosekunden zu vergleichen :

  1. Muster CASE_INSENSITIVE Regulärer Ausdruck : 399.387 ns
  2. String toLowerCase : 434.064 ns
  3. Apache Commons StringUtils : 496.313 ns
  4. String Region Spiele : 718,842 ns
  5. Zeichenfolge stimmt mit dem regulären Ausdruck überein: 3964.346 ns

Wie wir sehen können, ist der Gewinner Pattern mit aktiviertem CASE_INSENSITIVE- Flag, dicht gefolgt von toLowerCase () . Wir haben auch eine deutliche Verbesserung der Leistung zwischen Java 8 und Java 11 festgestellt.

8. Fazit

In diesem Tutorial haben wir uns verschiedene Möglichkeiten angesehen, einen String auf einen Teilstring zu überprüfen , während der Fall in Java ignoriert wurde.

Wir haben uns die Verwendung von String.toLowerCase () und toUpperCase () , String.matches () , String.regionMatches () , Apache Commons StringUtils.containsIgnoreCase () und Pattern.matcher () angesehen. Find () .

Außerdem haben wir die Leistung jeder Lösung bewertet und festgestellt, dass die Verwendung der Methode compile () aus java.util.regex.Pattern mit dem Flag CASE_INSENSITIVE die beste Leistung erbringt .

Wie immer ist der Code auf GitHub verfügbar.