Come Verificare se una Stringa Java Contiene una Sottostringa

Verificare se una String è contenuta all'interno di un'altra è una delle operazioni su testo più comuni in Java. Lo strumento giusto dipende da ciò di cui hai effettivamente bisogno: una semplice risposta sì/no, la posizione della corrispondenza, un controllo ancorato all'inizio o alla fine, oppure un pattern flessibile. Questo capitolo illustra ciascun approccio idiomatico e quando utilizzarlo.

L'approccio predefinito: `String.contains`

Quando hai bisogno solo di un boolean — "questo frammento è presente o no?" — contains è la scelta più chiara:

String text = "The quick brown fox";
boolean hasFox = text.contains("fox");   // true
boolean hasCat = text.contains("cat");   // false

contains accetta qualsiasi CharSequence (quindi String, StringBuilder, ecc.) e restituisce true se l'argomento compare in qualsiasi posizione della stringa. È case-sensitive: text.contains("FOX") è false. Un caso limite da ricordare — la stringa vuota è contenuta in ogni stringa, quindi text.contains("") è sempre true.

Quando serve la posizione: `indexOf`

contains è in realtà implementato sopra indexOf. Se hai bisogno di sapere dove inizia una corrispondenza (o vuoi cercare occorrenze ripetute), chiama direttamente indexOf:

String text = "The quick brown fox";
int at = text.indexOf("brown");   // 10
int no = text.indexOf("bird");    // -1

indexOf restituisce l'indice a base zero della prima corrispondenza, oppure -1 se la sottostringa è assente. L'idioma classico per verificare la presenza è text.indexOf("brown") >= 0, che è equivalente a contains ma ti fornisce anche la posizione gratuitamente. Esiste anche lastIndexOf per cercare dalla fine, e un overload che accetta un offset di partenza per trovare corrispondenze successive in un ciclo.

Controlli ancorati: `startsWith` e `endsWith`

Se ti interessa specificamente l'inizio o la fine di una stringa — estensioni di file, prefissi URL, schemi di protocollo — startsWith e endsWith esprimono l'intenzione direttamente e risultano più leggibili rispetto all'uso di slice:

String file = "report.pdf";
boolean isPdf  = file.endsWith(".pdf");      // true
boolean isHttp = "https://w3docs.com".startsWith("https://"); // true

Sono più veloci e più chiari di indexOf(prefix) == 0, perché smettono di confrontare non appena un carattere differisce e non eseguono mai la scansione dell'intera stringa.

Confronto case-insensitive e pattern matching

contains non ha un overload case-insensitive. La soluzione più semplice è normalizzare entrambi i lati:

boolean ci = text.toLowerCase().contains("FOX".toLowerCase()); // true

Per qualcosa di più di un semplice frammento letterale — alternative, caratteri jolly, confini di parola — usa un'espressione regolare. Pattern.compile(...).matcher(text).find() restituisce true se il pattern corrisponde in qualsiasi punto, e CASE_INSENSITIVE gestisce le maiuscole senza allocare copie in minuscolo:

import java.util.regex.Pattern;
boolean found = Pattern.compile("fox", Pattern.CASE_INSENSITIVE)
                       .matcher(text).find();

Approccio	Restituisce	Usa quando
`contains`	`boolean`	Semplice verifica di presenza, testo letterale
`indexOf`	`int` (posizione, o `-1`)	Hai bisogno di sapere dove si trova la corrispondenza
`startsWith` / `endsWith`	`boolean`	Ancorato all'inizio o alla fine
`Pattern.find`	`boolean`	Pattern, alternative, case-insensitive

Un esempio pratico

Questo programma esegue i quattro approcci uno accanto all'altro su una frase, incluso il problema della distinzione maiuscole/minuscole e il caso limite della stringa vuota.

java— editable, runs on the server

public class CheckSubstring {
  public static void main(String[] args) {
    String text = "The quick brown fox jumps over the lazy dog";

// contains(): the simplest yes/no membership test
    System.out.println("contains 'brown'   : " + text.contains("brown"));
    System.out.println("contains 'cat'     : " + text.contains("cat"));

// contains is case-sensitive
    System.out.println("contains 'FOX'     : " + text.contains("FOX"));

// case-insensitive: normalise both sides first
    boolean ci = text.toLowerCase().contains("FOX".toLowerCase());
    System.out.println("contains 'FOX' (ci): " + ci);

// indexOf(): position, or -1 when absent
    System.out.println("indexOf 'fox'      : " + text.indexOf("fox"));
    System.out.println("indexOf 'bird'     : " + text.indexOf("bird"));

// startsWith / endsWith: anchored checks
    System.out.println("startsWith 'The'   : " + text.startsWith("The"));
    System.out.println("endsWith 'dog'     : " + text.endsWith("dog"));

// empty string is always contained
    System.out.println("contains ''        : " + text.contains(""));
  }
}

Cosa ricavare dall'esecuzione:

contains "brown" stampa true e contains "cat" stampa false — contains è il test diretto di presenza boolean per testo letterale.
contains "FOX" stampa false anche se la parola "fox" è presente, dimostrando che contains è case-sensitive; la riga normalizzata contains "FOX" (ci) stampa true.
indexOf "fox" stampa 16, la posizione a base zero dell'inizio della corrispondenza, mentre indexOf "bird" stampa -1 per indicare "non trovato" — quel -1 è il valore sentinella da verificare.
startsWith "The" e endsWith "dog" stampano entrambi true, mostrando i controlli ancorati che leggono l'inizio e la fine della frase.
contains "" stampa true, il promemoria che ogni stringa contiene la stringa vuota — proteggiti dagli input vuoti se ciò rappresenterebbe un bug.

Argomenti correlati

Java Strings — la base per ogni metodo in questa pagina.
Java String Methods — il riferimento completo per contains, indexOf, startsWith e simili.
Come Confrontare Stringhe in Java — uguaglianza e ordinamento, il naturale seguito alla verifica di presenza.
Java Regex: Pattern e Matcher — approfondisci l'approccio basato sui pattern mostrato sopra.

Esercitazione

Pratica

Cosa restituisce text.indexOf('bird') quando 'bird' non è presente nella stringa text?

-10nullLancia una StringIndexOutOfBoundsException

L'approccio predefinito: String.contains

Quando serve la posizione: indexOf

Controlli ancorati: startsWith e endsWith