Corrispondenza di stringhe senza distinzione tra maiuscole e minuscole in Java

1. Panoramica

Esistono molti modi per verificare se una stringa contiene una sottostringa. In questo articolo, cercheremo sottostringhe all'interno di una stringa concentrandoci su soluzioni alternative senza distinzione tra maiuscole e minuscole per String.contains () in Java. Ancora più importante, forniremo esempi di come risolvere questo problema.

2. La soluzione più semplice: String.toLowerCase

La soluzione più semplice è usare String.toLowerCase () . In questo caso, trasformeremo entrambe le stringhe in lettere minuscole e quindi utilizzeremo il metodo contains () :

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

Possiamo anche usare String.toUpperCase () e fornirebbe lo stesso risultato.

3. String.matches con espressioni regolari

Un'altra opzione è usare String.matches () con espressioni regolari:

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

Il metodo match () richiede un S tring per rappresentare l'espressione regolare. (? i) abilita la distinzione tra maiuscole e minuscole e . * utilizza tutti i caratteri tranne le interruzioni di riga.

4. String.regionMatches

Possiamo anche usare String.regionMatches () . Controlla se due regioni String corrispondono, utilizzando true per il parametro 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));

Per migliorare le prestazioni, inizia ad abbinare la regione, tenendo conto della lunghezza della stringa di destinazione . Quindi, diminuisce l'iteratore.

5. Pattern con l' opzione CASE_INSENSITIVE

La classe java.util.regex.Pattern ci fornisce un modo per abbinare le stringhe utilizzando il metodo matcher () . In questo caso, possiamo usare il metodo quote () per eseguire l'escape di qualsiasi carattere speciale e il flag CASE_INSENSITIVE . Diamo un'occhiata:

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

6. Apache Commons StringUtils.containsIgnoreCase

Infine, trarremo vantaggio dalla classe StringUtils di Apache Commons :

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

7. Confronto delle prestazioni

Come in questo articolo generale sul controllo delle sottostringhe utilizzando il metodo contiene , abbiamo utilizzato il framework open source Java Microbenchmark Harness (JMH) per confrontare le prestazioni dei metodi in nanosecondi :

  1. Pattern CASE_INSENSITIVE Regular Expression : 399.387 ns
  2. String toLowerCase : 434.064 ns
  3. Apache Commons StringUtils : 496.313 ns
  4. Corrispondenze regione stringa : 718.842 ns
  5. La stringa corrisponde all'espressione regolare : 3964.346 ns

Come possiamo vedere, il vincitore è Pattern con il flag CASE_INSENSITIVE abilitato, seguito da vicino da toLowerCase () . Abbiamo anche notato un netto miglioramento delle prestazioni tra Java 8 e Java 11.

8. Conclusione

In questo tutorial, abbiamo esaminato alcuni modi diversi per controllare una stringa per una sottostringa, ignorando il caso in Java.

Abbiamo esaminato l'utilizzo di String.toLowerCase () e toUpperCase () , String.matches () , String.regionMatches () , Apache Commons StringUtils.containsIgnoreCase () e Pattern.matcher (). Find () .

Inoltre, abbiamo valutato le prestazioni di ciascuna soluzione e abbiamo scoperto che l'utilizzo del metodo compile () da java.util.regex.Pattern con il flag CASE_INSENSITIVE ha dato i risultati migliori .

Come sempre, il codice è disponibile su GitHub.