Metodi della Classe String in Java

La classe String include decine di metodi. Questo capitolo è un riferimento pratico di quelli che utilizzerai davvero, raggruppati per funzione: ispezione, confronto, ricerca, suddivisione, trasformazione, splitting/joining, conversione e formattazione.

Ricorda: le stringhe sono immutabili. Ogni metodo restituisce una nuova stringa (o un altro valore) — non modifica mai la stringa su cui viene chiamato. Ciò significa che una chiamata come s.toUpperCase(); da sola non è utile; devi catturare il risultato:

String s = "hello";
s.toUpperCase();        // result discarded — s is still "hello"
s = s.toUpperCase();    // s is now "HELLO"

Gli indici sono a base zero e contano le unità di codice UTF-16, non i caratteri percepiti dall'utente, il che è rilevante per emoji e altri caratteri supplementari.

Ispezione di una stringa

"hello".length();      // 5
"".isEmpty();          // true
"   ".isBlank();       // true
"hello".charAt(1);     // 'e'

Confronto di stringhe

"hi".equals("hi");                  // true
"HI".equalsIgnoreCase("hi");        // true
"apple".compareTo("banana");        // negative

Preferisci sempre .equals() a == per il confronto del contenuto (Operatori di Confronto). == confronta i riferimenti agli oggetti — se due variabili puntano allo stesso oggetto — non i caratteri al loro interno. Poiché Java interna i letterali stringa, == sembra funzionare a volte, ma fallisce nel momento in cui una stringa viene costruita a runtime:

String a = "hi";
String b = "hi";
String c = new String("hi");

a == b;          // true  — both point to the same interned literal
a == c;          // false — c is a different object
a.equals(c);     // true  — same contents

compareTo è quello che ti serve per l'ordinamento: restituisce un numero negativo, zero o un numero positivo, quindi si integra direttamente in Collections.sort o nelle catene Comparator.

Ricerca

String s = "abc-xyz-abc";
s.contains("xyz");       // true
s.indexOf("abc");        // 0
s.lastIndexOf("abc");    // 8
s.startsWith("abc");     // true
s.endsWith("xyz");       // false

Suddivisione

String s = "Hello, World!";
s.substring(7);        // "World!"
s.substring(7, 12);    // "World"

Gli indici negativi non sono consentiti — generano una StringIndexOutOfBoundsException.

Trasformazione

"  hello  ".strip();                 // "hello"
"banana".replace("a", "_");          // "b_n_n_"
"hello".repeat(3);                   // "hellohellohello"
"abc 123".replaceAll("\\d", "*");    // "abc ***"

Splitting e joining

"a,b,c".split(",");                     // ["a","b","c"]
String.join("-", "a", "b", "c");        // "a-b-c"
String.join(",", List.of("a","b"));     // "a,b"
"line1\nline2\nline3".lines().count();  // 3

split accetta un'espressione regolare, non una stringa semplice — quindi effettua l'escape dei metacaratteri regex: usa split("\\.") per dividere su un punto letterale, non split(".") (che corrisponde a ogni carattere e restituisce un array vuoto). Le stringhe vuote finali vengono eliminate per impostazione predefinita; passa un limit negativo (ad es. split(",", -1)) per mantenerle.

Conversione

String.valueOf(42);              // "42"
Integer.parseInt("42");          // 42
Double.parseDouble("3.14");      // 3.14
"hello".toCharArray();           // {'h','e','l','l','o'}

I metodi parse* generano una NumberFormatException se il testo non è un numero valido, quindi racchiudi l'input dell'utente in un blocco try/catch o validalo prima. A differenza di parseInt, String.valueOf(null) è sicuro — restituisce la stringa "null" invece di lanciare un'eccezione.

Formattazione

String.format("%s is %d", "Ada", 36);     // "Ada is 36"
"%s is %d".formatted("Ada", 36);          // "Ada is 36"

Una dimostrazione completa

Cosa fare dopo

Concatenazione di Stringhe in Java approfondisce +, concat e StringBuilder, incluso quando ciascuno è lo strumento giusto da usare.

Esercitazione