1. Confronto dei riferimenti e del contenuto
In Java le stringhe sono oggetti, non tipi primitivi. Quando dichiari le variabili a e b, possono riferirsi alla stessa stringa nel pool delle stringhe. Invece c, creata tramite costruttore, è già un altro oggetto. L’operatore == confronta i riferimenti, non il testo.
String a = "hello";
String b = "hello";
String c = new String("hello");
System.out.println(a == b); // true (molto probabilmente stringa internata)
System.out.println(a == c); // false (oggetti diversi)
Dimostrazione di un errore
String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1 == s2); // false
Sebbene le stringhe sembrino uguali, sono oggetti diversi in memoria.
2. equals(): confronto del contenuto delle stringhe
Per confrontare il contenuto, usa il metodo equals() — confronta le stringhe carattere per carattere (tenendo conto del caso).
String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1.equals(s2)); // true
Esempio: confronto di password
String inputPassword = "Secret123";
String realPassword = "Secret123";
if (inputPassword.equals(realPassword))
{
System.out.println("Accesso consentito!");
}
else
{
System.out.println("Password errata.");
}
Importante!
Se almeno uno degli oggetti è null, chiamare equals() porterà a un NullPointerException. Modello sicuro:
if ("qualcosa".equals(someString)) { ... }
3. equalsIgnoreCase(): confronto senza distinzione tra maiuscole e minuscole
Quando è importante ignorare il caso (ad esempio, input dell’utente), usa equalsIgnoreCase().
String name1 = "Ivan";
String name2 = "ivan";
System.out.println(name1.equalsIgnoreCase(name2)); // true
Esempio: confronto di indirizzi email
String email1 = "User@Example.com";
String email2 = "user@example.com";
if (email1.equalsIgnoreCase(email2))
{
System.out.println("Le email coincidono!");
}
In breve: equals vs equalsIgnoreCase
| Metodo | Distingue maiuscole/minuscole? | Esempio "Java" vs "java" |
|---|---|---|
|
Sì | |
|
No | |
4. compareTo(): confronto lessicografico delle stringhe
Il metodo compareTo() esegue un confronto lessicografico (da dizionario). Restituisce un numero negativo se la prima stringa è «minore», 0 — uguali, positivo — se è «maggiore».
System.out.println("apple".compareTo("banana")); // < 0
System.out.println("apple".compareTo("apple")); // 0
System.out.println("banana".compareTo("apple")); // > 0
a.compareTo(b) →
< 0 — se a viene prima di b
0 — se sono uguali
> 0 — se a viene dopo bcompareTo()
Come funziona?
- Il confronto procede da sinistra a destra in base ai codici Unicode dei caratteri.
- Alla prima differenza viene restituita la differenza tra i codici dei caratteri.
- Se una stringa è prefisso dell’altra, quella più corta è «minore».
System.out.println("cat".compareTo("catalog")); // < 0 ("cat" è più corta)
System.out.println("catalog".compareTo("cat")); // > 0
Esempio: ordinamento di un array di stringhe
String[] fruits = {"banana", "apple", "pear"};
Arrays.sort(fruits); // internamente usa compareTo()
System.out.println(Arrays.toString(fruits)); // [apple, banana, pear]
compareToIgnoreCase()
System.out.println("Java".compareToIgnoreCase("java")); // 0
5. Metodi startsWith() ed endsWith()
I metodi startsWith() e endsWith() verificano l’inizio e la fine di una stringa, restituendo true/false.
String fileName = "document.pdf";
String url = "https://www.google.com";
System.out.println(fileName.startsWith("doc")); // true
System.out.println(fileName.endsWith(".txt")); // false
System.out.println(url.startsWith("https://")); // true
A cosa serve: validazione di formati (nomi di file, URL) e filtraggio per prefissi/suffissi (ad esempio, tutti i ".jpg").
6. Metodo contains(): cercare una sottostringa
contains(CharSequence s) è un modo semplice per verificare la presenza di una sottostringa. È sensibile al maiuscolo/minuscolo.
String text = "Benvenuto nel mondo di Java!";
System.out.println(text.contains("mondo")); // true
System.out.println(text.contains("C++")); // false
Per ignorare il caso, porta entrambe le stringhe allo stesso caso: toLowerCase()/toUpperCase().
7. Metodi toLowerCase() e toUpperCase()
Restituiscono una nuova stringa convertita in minuscolo o maiuscolo. Utile per confronti senza distinzione tra maiuscole/minuscole e per la formattazione.
String title = "Java Programming";
String lower = title.toLowerCase();
String upper = title.toUpperCase();
System.out.println(lower); // java programming
System.out.println(upper); // JAVA PROGRAMMING
8. Metodo split(): dividere una stringa in parti
split(String regex) divide la stringa in base a un delimitatore (espressione regolare) e restituisce un array String[].
Esempio 1: per virgole
String names = "Alex,Maria,Ivan,Elena";
String[] nameArray = names.split(",");
for (String name : nameArray)
{
System.out.println(name.trim()); // trim() rimuove eventuali spazi
}
// Output:
// Alex
// Maria
// Ivan
// Elena
Esempio 2: per spazi
String sentence = "Sto studiando Java";
String[] words = sentence.split(" ");
for (String word : words)
{
System.out.println(word);
}
// Output:
// Sto
// studiando
// Java
Particolarità:
- Il delimitatore è una regex. I caratteri speciali vanno escapati (ad esempio, il punto: "\\.").
- Il metodo restituisce sempre un array, anche di un solo elemento.
9. Pratica: confrontare stringhe in un’applicazione reale
String registeredEmail = "user@example.com";
String registeredPassword = "Secret123";
Scanner console = new Scanner(System.in);
System.out.print("Inserisci l'email: ");
String email = console.nextLine();
System.out.print("Inserisci la password: ");
String password = console.nextLine();
// Confrontiamo l'email ignorando il maiuscolo/minuscolo, e la password rispettando il caso
if (email.equalsIgnoreCase(registeredEmail) && password.equals(registeredPassword))
{
System.out.println("Benvenuti!");
}
else
{
System.out.println("Email o password non corretti.");
}
Commenti: per l’email usiamo equalsIgnoreCase(), mentre per la password — rigorosamente equals(). L’operatore == non va usato per le stringhe — confronta i riferimenti.
10. Errori tipici nel confronto delle stringhe
Errore n. 1: confronto delle stringhe con == invece di equals()
L’operatore == confronta i riferimenti, non il contenuto, quindi il risultato può essere inaspettato.
Errore n. 2: chiamare equals() su un oggetto che potrebbe essere null
Chiama il metodo su un oggetto sicuramente non null oppure usa Objects.equals(a, b).
Errore n. 3: ignorare il caso quando è importante
Ad esempio, le password devono essere confrontate rispettando maiuscole/minuscole. Definite i requisiti.
Errore n. 4: confronto di stringhe con oggetti di altri tipi
"123" e 123 non sono la stessa cosa. equals() non effettua conversioni di tipo automaticamente.
Errore n. 5: ordinare stringhe con casi diversi
Le lettere maiuscole vengono prima delle minuscole. Per un ordinamento senza distinzione tra maiuscole/minuscole usa Arrays.sort(array, String.CASE_INSENSITIVE_ORDER).
GO TO FULL VERSION