Classi helper per lavorare con le stringhe in Java

1. StringTokenizerclasse

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:

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. È difficile da leggere e quindi difficile da modificare.

StringTokenizerclasse

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.

String nextToken()

boolean hasMoreTokens()

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

Puoi creare un StringTokenizeroggetto con questo comando:

StringTokenizer name = new StringTokenizer(string, delimiters);

Dov'è stringla stringa da dividere in parti. Ed delimitersè 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
!

Si noti che ogni carattere nella stringa passata come seconda stringa al StringTokenizercostruttore è considerato un separatore.

2. String.format()metodo e StringFormatterclasse

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):

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

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

Il tuo codice sarà probabilmente 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.}");

Tale codice non è molto leggibile. E se i nomi delle variabili fossero più lunghi, il codice diventerebbe ancora più difficile:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

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

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:

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, scriviamo %s. Se 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 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

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

3. Pool di stringhe

Ogni stringa specificata nel codice come stringa letterale viene memorizzata 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 (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 StringPoolnon 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ù Stringvariabili 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.

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 Stringdella variabile intern().

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

Se due stringhe identiche vengono aggiunte all'utilizzo StringPooldel intern()metodo, il metodo restituisce lo stesso riferimento. Questo può essere usato 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 tu usi spesso questo metodo, ma le persone adorano chiederlo durante le interviste . Quindi è meglio saperlo che non sapere.