1. StringTokenizer
classe
E ora alcuni scenari più comuni che coinvolgono il lavoro con le stringhe. Come si divide una stringa in più parti? Ci sono diversi modi per farlo.
split()
metodo
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 argomento. Imparerai cos'è un'espressione regolare nella ricerca Java Multithreading .
Esempio:
Codice | Risultato |
---|---|
|
Il risultato sarà un array di tre stringhe:
|
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. È difficile da leggere e quindi difficile da modificare.
StringTokenizer
classe
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 un passo alla volta.
La classe ha un costruttore e due metodi importanti. Passiamo al costruttore una stringa che abbiamo diviso in parti e una stringa composta da un insieme di caratteri di delimitazione.
Metodi | Descrizione |
---|---|
|
Restituisce la sottostringa successiva |
|
Controlla se ci sono più sottostringhe. |
Questa classe ricorda in qualche modo la classe Scanner, che ha anche metodi nextLine()
e hashNextLine()
.
Puoi creare un StringTokenizer
oggetto con questo comando:
StringTokenizer name = new StringTokenizer(string, delimiters);
Dov'è string
la stringa da dividere in parti. Ed delimiters
è una stringa e ogni carattere in essa contenuto viene trattato come un delimitatore. Esempio:
Codice | Uscita console |
---|---|
|
|
Si noti che ogni carattere nella stringa passata come seconda stringa al StringTokenizer
costruttore è considerato un separatore.
2. String.format()
metodo e StringFormatter
classe
Un altro metodo interessante della classe String è format()
.
Diciamo che hai 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):
Codice | Uscita console |
---|---|
|
|
Il tuo codice sarà probabilmente simile a questo:
Codice del programma |
---|
|
Tale codice non è molto leggibile. E se i nomi delle variabili fossero più lunghi, il codice diventerebbe ancora più difficile:
Codice del programma |
---|
|
Non molto leggibile, vero?
Ma 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 classe String ha un metodo statico format()
: 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:
Codice | Risultato |
---|---|
|
|
|
|
|
|
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 %d
e %s
) nei punti in cui è necessario inserire i dati.
Il format()
metodo sostituisce questi %s
e %d
gli identificatori di formato con i parametri che seguono la stringa di formato nell'elenco dei parametri. Se vogliamo inserire una stringa, scriviamo %s
. Se vogliamo inserire un numero, allora l'identificatore di formato è %d
. Esempio:
Codice | Risultato |
---|---|
|
s è uguale a"a=1, b=4, c=3" |
Ecco un breve elenco di identificatori di formato che possono essere utilizzati all'interno della stringa di formato:
Specificatore | Senso |
---|---|
|
String |
|
intero: byte , short , int ,long |
|
numero reale: float ,double |
|
boolean |
|
char |
|
Date |
|
% carattere |
Questi specificatori indicano il tipo di dati, ma esistono anche specificatori che indicano l'ordine dei dati. Per ottenere un argomento in base al suo numero (la numerazione parte da uno), devi scrivere " " invece di " ". Esempio:%1$d
%d
Codice | Risultato |
---|---|
|
s è uguale a"a=13, b=12, c=11" |
%3$d
otterrà il terzo argomento, %2$d
otterrà il secondo argomento e %d
otterrà il primo argomento. Gli identificatori di formato %s
e %d
si riferiscono ad argomenti indipendentemente da identificatori come %3$d
o%2$s
3. Pool di stringhe
Ogni stringa specificata nel codice come stringa letterale viene memorizzata in un'area di memoria chiamata the StringPool
mentre 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 (soprattutto stringhe di grandi dimensioni) devono essere archiviati in memoria separatamente dal codice. Nel codice vengono visualizzati solo i riferimenti a 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 tua classe viene caricato dalla macchina Java, tutti i valori letterali stringa vengono aggiunti a se StringPool
non sono già presenti. Se sono già presenti, usiamo semplicemente un riferimento di stringa dal file StringPool
.
Di conseguenza, se assegni lo stesso valore letterale a più String
variabili nel tuo codice, queste variabili conterranno lo stesso riferimento. Verrà aggiunto un valore letterale a StringPool
only once. In tutti gli altri casi, il codice otterrà un riferimento alla stringa già caricata nel file StringPool
.
Ecco più o meno come funziona:
Codice | Lavorare con StringPool |
---|---|
|
|
Ecco perché le variabili a
e b
memorizzeranno gli stessi riferimenti.
intern()
metodo
E la parte migliore è che puoi aggiungere a livello di codice qualsiasi stringa al file StringPool
. Per fare ciò, devi solo chiamare il metodo String
della variabile intern()
.
Il intern()
metodo aggiungerà la stringa al StringPool
se non è già presente e restituirà un riferimento alla stringa nel file StringPool
.
Se due stringhe identiche vengono aggiunte all'utilizzo StringPool
del intern()
metodo, il metodo restituisce lo stesso riferimento. Questo può essere usato per confrontare le stringhe per riferimento. Esempio:
Codice | Nota |
---|---|
|
|
|
|
È improbabile che tu usi spesso questo metodo, ma le persone adorano chiederlo durante le interviste . Quindi è meglio saperlo che non sapere.
GO TO FULL VERSION