StringBuilder in Java: come funziona la classe modificabile

La classe StringBuilder può essere utilizzata in Java per apportare modifiche direttamente all’interno di una stringa, cosa altrimenti non possibile con le stringhe convenzionali. Queste modifiche possono essere inizializzate usando diversi metodi.

StringBuilder in Java: un’alternativa alle stringhe convenzionali

La classe String di Java è una classe finale, immutabile e che non richiede alcuna sottoclasse. La classe StringBuilder rappresenta un’alternativa a String che, al contrario di quest’ultima, è in grado di creare una sequenza di caratteri la quale può essere modificata anche dopo essere stata creata. StringBuilder svolge quindi un compito simile a StringBuffer, ma con la differenza principale che StringBuilder non è sincronizzata, risultando quindi particolarmente consigliata per lavorare con un singolo thread, in quanto in grado di funzionare molto più velocemente rispetto a StringBuffer. Ti mostriamo le caratteristiche di StringBuilder e le sue funzionalità.

Sintassi e utilità

La sintassi di StringBuilder in Java segue sempre lo stesso schema e si presenta come segue:

public final class StringBuilder
	extends Object
		implements Serializable, CharSequence

Per capire come funziona questa classe e qual è il suo scopo, bisogna prima dare un’occhiata alla normale classe String. In String, una volta dichiarato un oggetto, questo non può più essere modificato. Se desideri apportare delle modifiche, dovrai creare un nuovo oggetto e salvarlo con il valore modificato. Questo comporta uno spreco di dati e può causare un peggioramento delle prestazioni. Utilizzando invece StringBuilder in Java per una sequenza di caratteri, le modifiche vengono apportate a questa sequenza senza creare una nuova stringa. Questo permette di ridurre gli sprechi e ottimizzare le prestazioni.

Costruttori della classe

StringBuilder ha quattro costruttori che aiutano a convertire la stringa nel formato appropriato per la classe e che vengono utilizzati anche per la configurazione. Di seguito vediamo che cosa sono i costruttori e i loro compiti:

• StringBuilder(): genera una classe StringBuilder vuota con una capacità massima di 16 caratteri.
• StringBuilder(int capacity): crea una classe StringBuilder senza caratteri, il cui numero massimo di caratteri è definito dall’argomento “capacity”.
• StringBuilder(CharSequence seq): genera una classe StringBuilder con gli stessi caratteri della sequenza di caratteri memorizzata.
• StringBuilder(String str): crea una classe StringBuilder basata sulla stringa memorizzata.

Il modo migliore per illustrare il funzionamento pratico dei costruttori è servirsi di un esempio di codice. Di seguito vedi come funzionano tutte e quattro le opzioni:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
	str.append("ABC");
	System.out.println("Primo costruttore = " + str.toString());
	StringBuilder str2 = new StringBuilder(5);
	System.out.println("Secondo costruttore = " + str2.capacity());
	StringBuilder str3 = new StringBuilder("ABCDEFGHIJK");
	System.out.println("Terzo costruttore = " + str3.toString());
	StringBuilder str4 = new StringBuilder(str3.toString());
	System.out.println("Quarto costruttore = " + str4.toString());
	}
}

Utilizzando il comando Java System.out.println per l’output, otterrai questo risultato:

Primo costruttore = ABC
Secondo costruttore = 5
Terzo costruttore = ABCDEFGHIJK
Quarto costruttore = ABCDEFGHIJK

Esempi di metodi per StringBuilder in Java

Esistono numerosi metodi per la classe Java StringBuilder. Qui ti presentiamo alcuni dei più importanti, con i relativi frammenti di codice.

append()

Il metodo append() viene utilizzato per aggiungere una stringa a un’altra e ha diversi parametri. Vediamo come si presenta nel seguente esempio pratico:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.append("FGHIJK");
	System.out.println(str);
	}
}

Come output si ottiene:

ABCDEFGHIJK

insert()

Il metodo insert() viene utilizzato in combinazione con la classe StringBuilder di Java per inserire una stringa in una posizione specifica. Può presentarsi così:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.insert(1,"FGHIJK");
	System.out.println(str);
	}
}

Questo sarà l’output corrispondente:

AFGHIJKBCDEFGHIJK

Usa il numero intero (in questo caso 1) per specificare il punto in cui la stringa deve essere inserita.

replace()

Il metodo replace() sostituisce una stringa o parte di essa. Viene definita da beginIndex e endIndex, come nel seguente esempio:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.replace(1,4,"FGHIJK");
	System.out.println(str);
	}
}

Ne risulterà il seguente output:

AFGHIJKE

reverse()

Il metodo reverse() ti consente di invertire completamente la stringa memorizzata. Illustriamo anche questo metodo con un esempio pratico:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.reverse();
	System.out.println(str);
	}
}

Il risultato è il seguente:

EDCBA

delete()

Il metodo delete() di StringBuilder in Java ti permette di cancellare l’intera stringa o una parte di essa. Anche questa parte può essere definita tramite beginIndex e endIndex, come illustrato in questo esempio:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.delete(1,4);
	System.out.println(str);
	}
}

L’output corrispondente è il seguente:

AE

capacity()

Il metodo capacity() fornisce il numero massimo attuale di caratteri della classe StringBuilder di Java. Questo corrisponde generalmente a 16. Può essere aumentato secondo la formula “Lunghezza precedente dei caratteri * 2 + 2”. Quindi, se in precedenza era di 16 caratteri, viene raddoppiato (32) e aumentato di due (34). Puoi vedere un esempio concreto qui:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("Ecco un altro esempio");
	System.out.println(str.capacity());
	}
}

Come output si ottiene:

16
16
34

ensureCapacity()

Il metodo ensureCapacity() assicura che il numero di caratteri disponibili corrisponda ad almeno un valore definito. Se così non fosse, la capacità viene nuovamente estesa secondo la formula “Lunghezza precedente dei caratteri * 2 + 2”. Lo puoi vedere in questo esempio:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("Ecco un altro esempio");
	System.out.println(str.capacity());
	str.ensureCapacity(5);
	System.out.println(str.capacity());
	str.ensureCapacity(40);
	System.out.println(str.capacity());
	}
}

Questo è l’output corrispondente:

16
16
34
34
70

Per prima cosa, è stato preso in considerazione per due volte il valore standard (16), poi due volte il valore doppio più due (34) e infine il valore è stato nuovamente raddoppiato e sommato a due (70).