Classi di convenienza per lavorare con le stringhe in Java

Un frammento di lezione con un mentore come parte del corso Codegym University. Iscriviti al corso completo.

"Ciao, Amigo! Oggi analizzeremo alcuni scenari più comuni che coinvolgono il lavoro con le stringhe. Ad esempio, sai come dividere una stringa in più parti?"

"Non te lo dirò subito, Ellie. Ma me lo dirai tu, vero?"

split()metodo

"Ci sono diversi modi per farlo. Il primo modo per dividere una stringa in più parti è utilizzare il split()metodo. Un'espressione regolare che definisce una stringa di delimitazione speciale deve essere passata come parametro. Imparerai cos'è un'espressione regolare in la ricerca delle raccolte Java .

Esempio:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

Semplice, ma a volte questo approccio è eccessivo. Se sono presenti molti delimitatori (ad esempio spazi, caratteri di nuova riga, tabulazioni, punti), è necessario costruire un'espressione regolare piuttosto complessa."

"Beh, certo. E se è difficile da leggere, allora è difficile apportare modifiche.

StringTokenizerclasse

Un frammento di lezione con un mentore come parte del corso Codegym University. Iscriviti al corso completo.

"Java ha una classe speciale il cui intero compito è dividere una stringa in sottostringhe.

"Questa classe non usa espressioni regolari: invece, passi semplicemente una stringa composta da delimitatori. Il vantaggio di questo approccio è che non spezza l'intera stringa in pezzi tutti in una volta, ma invece si sposta dall'inizio alla fine di un passo alla volta.

La classe ha un costruttore e due metodi. Passiamo al costruttore una stringa che abbiamo diviso in parti e una stringa composta da un insieme di caratteri di delimitazione.

String nextToken()

boolean hasMoreTokens()

"Questa classe in qualche modo mi ricorda la classe Scanner, che ha anche metodi nextLine()e hashNextLine().

"Questa è una buona osservazione che hai fatto. Puoi creare un StringTokenizeroggetto con questo comando:

StringTokenizer name = new StringTokenizer(string, delimiters);

Dove stringa è la stringa da dividere in parti. E delimitatori è una stringa e ogni carattere in essa contenuto viene trattato come un delimitatore. Esempio:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

"Notare che ogni carattere nella stringa passato nella seconda stringa al StringTokenizercostruttore è considerato un separatore.

String.format()metodo e StringFormatterclasse

"Un altro metodo interessante della classe String è format().

"Supponiamo che tu abbia varie variabili che memorizzano i dati. Come li visualizzi sullo schermo in una riga? Ad esempio, abbiamo alcuni dati (colonna di sinistra) e l'output desiderato (colonna di destra):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

Il codice per un tale programma sarà simile a questo:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

"Sarai d'accordo con me che il codice non è molto leggibile. E se i nomi delle variabili fossero più lunghi, allora il codice diventerebbe ancora più difficile:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

"Sì, è una lettura difficile!"

"Non preoccuparti. Questa è una situazione comune nei programmi del mondo reale, quindi voglio parlarti di un modo per scrivere questo codice in modo più semplice e conciso.

String.format

"La Stringclasse ha un metodo statico format(): ti consente di specificare un modello per assemblare una stringa con i dati. L'aspetto generale del comando è il seguente:

String name = String.format(pattern, parameters);

Esempio:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

"Il format()primo parametro del metodo è una stringa di formato che contiene tutto il testo desiderato insieme a caratteri speciali chiamati identificatori di formato (come %de %s) nei punti in cui è necessario inserire i dati.

"Il format()metodo sostituisce questi %se %dgli identificatori di formato con i parametri che seguono la stringa di formato nell'elenco dei parametri. Se vogliamo inserire una stringa, allora scriviamo . %sSe vogliamo inserire un numero, allora l'identificatore di formato è %d. Esempio:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

"Ecco un breve elenco di identificatori di formato che possono essere utilizzati all'interno della stringa di formato:

%s

%d

%f

%b

%c

%t

%%

"Questi specificatori indicano il tipo di dati, ma ci sono anche specificatori che indicano l'ordine dei dati. Per ottenere un argomento in base al suo numero (la numerazione parte da uno), devi scrivere " % 1$ d " invece di " %d ". Esempio:

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$dotterrà il terzo argomento, %2$dotterrà il secondo argomento e %dotterrà il primo argomento. Gli identificatori di formato %se %dsi riferiscono ad argomenti indipendentemente da identificatori come %3$do%2$s

Piscina di stringhe

"Ogni stringa specificata nel codice come stringa letterale viene archiviata in un'area di memoria chiamata the StringPoolmentre il programma è in esecuzione. StringPoolè un array speciale per la memorizzazione di stringhe. Il suo scopo è ottimizzare l'archiviazione delle stringhe:

"Innanzitutto, le stringhe specificate nel codice devono essere memorizzate da qualche parte, giusto? Il codice è costituito da comandi, ma i dati (in particolare le stringhe di grandi dimensioni) devono essere archiviati in memoria separatamente dal codice. Nel codice compaiono solo i riferimenti agli oggetti stringa.

"In secondo luogo, tutti i valori letterali stringa identici devono essere archiviati in memoria solo una volta. Ed è proprio così che funziona. Quando il codice della classe viene caricato dalla macchina Java, tutti i valori letterali stringa vengono aggiunti a se non sono già presenti. Se lo StringPoolsono già lì, allora usiamo semplicemente un riferimento di stringa dal file StringPool.

Di conseguenza, se assegni lo stesso valore letterale a diverse variabili String nel tuo codice, queste variabili conterranno lo stesso riferimento. Verrà aggiunto un valore letterale a StringPoolonly once. In tutti gli altri casi, il codice otterrà un riferimento alla stringa già caricata nel file StringPool.

Ecco più o meno come funziona:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

"Ecco perché le variabili ae bmemorizzeranno gli stessi riferimenti."

"Spero di aver capito tutto correttamente.

intern()metodo.

"E la parte migliore è che puoi aggiungere a livello di codice qualsiasi stringa a StringPool. Per fare ciò, devi solo chiamare il metodo Stringdella variabile .intern()

"Il intern()metodo aggiungerà la stringa al StringPoolse non è già presente e restituirà un riferimento alla stringa nel file StringPool.

"E cosa accadrà se due stringhe identiche vengono aggiunte all'utilizzo StringPooldel intern()metodo?"

"Il metodo restituirà gli stessi riferimenti. Questo può essere utilizzato per confrontare le stringhe per riferimento. Esempio:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

È improbabile che utilizzi spesso questo metodo. Detto questo, alla gente piace chiederlo nei colloqui di lavoro.

"Quindi, è meglio sapere che non sapere. Grazie, Ellie!"