String­Buil­der in Java: come funziona la classe mo­di­fi­ca­bi­le

La classe String­Buil­der può essere uti­liz­za­ta in Java per apportare modifiche di­ret­ta­men­te all’interno di una stringa, cosa al­tri­men­ti non possibile con le stringhe con­ven­zio­na­li. Queste modifiche possono essere ini­zia­liz­za­te usando diversi metodi.

String­Buil­der in Java: un’al­ter­na­ti­va alle stringhe con­ven­zio­na­li

La classe String di Java è una classe finale, im­mu­ta­bi­le e che non richiede alcuna sot­to­clas­se. La classe String­Buil­der rap­pre­sen­ta un’al­ter­na­ti­va a String che, al contrario di quest’ultima, è in grado di creare una sequenza di caratteri la quale può essere mo­di­fi­ca­ta anche dopo essere stata creata. String­Buil­der svolge quindi un compito simile a String­Buf­fer, ma con la dif­fe­ren­za prin­ci­pa­le che String­Buil­der non è sin­cro­niz­za­ta, ri­sul­tan­do quindi par­ti­co­lar­men­te con­si­glia­ta per lavorare con un singolo thread, in quanto in grado di fun­zio­na­re molto più ve­lo­ce­men­te rispetto a String­Buf­fer. Ti mostriamo le ca­rat­te­ri­sti­che di String­Buil­der e le sue fun­zio­na­li­tà.

Sintassi e utilità

La sintassi di String­Buil­der 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 di­chia­ra­to un oggetto, questo non può più essere mo­di­fi­ca­to. Se desideri apportare delle modifiche, dovrai creare un nuovo oggetto e salvarlo con il valore mo­di­fi­ca­to. Questo comporta uno spreco di dati e può causare un peg­gio­ra­men­to delle pre­sta­zio­ni. Uti­liz­zan­do invece String­Buil­der 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 ot­ti­miz­za­re le pre­sta­zio­ni.

Co­strut­to­ri della classe

String­Buil­der ha quattro co­strut­to­ri che aiutano a con­ver­ti­re la stringa nel formato ap­pro­pria­to per la classe e che vengono uti­liz­za­ti anche per la con­fi­gu­ra­zio­ne. Di seguito vediamo che cosa sono i co­strut­to­ri e i loro compiti:

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

Il modo migliore per il­lu­stra­re il fun­zio­na­men­to pratico dei co­strut­to­ri è servirsi di un esempio di codice. Di seguito vedi come fun­zio­na­no 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());
	}
}

Uti­liz­zan­do 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 String­Buil­der in Java

Esistono numerosi metodi per la classe Java String­Buil­der. Qui ti pre­sen­tia­mo alcuni dei più im­por­tan­ti, con i relativi frammenti di codice.

append()

Il metodo append() viene uti­liz­za­to per ag­giun­ge­re 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 uti­liz­za­to in com­bi­na­zio­ne con la classe String­Buil­der di Java per inserire una stringa in una posizione specifica. Può pre­sen­tar­si 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 cor­ri­spon­den­te:

AFGHIJKBCDEFGHIJK

Usa il numero intero (in questo caso 1) per spe­ci­fi­ca­re il punto in cui la stringa deve essere inserita.

replace()

Il metodo replace() so­sti­tui­sce una stringa o parte di essa. Viene definita da be­gi­nIn­dex 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 com­ple­ta­men­te la stringa me­mo­riz­za­ta. Il­lu­stria­mo 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 String­Buil­der in Java ti permette di can­cel­la­re l’intera stringa o una parte di essa. Anche questa parte può essere definita tramite be­gi­nIn­dex e endIndex, come il­lu­stra­to 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 cor­ri­spon­den­te è il seguente:

AE

capacity()

Il metodo capacity() fornisce il numero massimo attuale di caratteri della classe String­Buil­der di Java. Questo cor­ri­spon­de ge­ne­ral­men­te a 16. Può essere aumentato secondo la formula “Lunghezza pre­ce­den­te dei caratteri * 2 + 2”. Quindi, se in pre­ce­den­za era di 16 caratteri, viene rad­dop­pia­to (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 di­spo­ni­bi­li cor­ri­spon­da ad almeno un valore definito. Se così non fosse, la capacità viene nuo­va­men­te estesa secondo la formula “Lunghezza pre­ce­den­te 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 cor­ri­spon­den­te:

16
16
34
34
70

Per prima cosa, è stato preso in con­si­de­ra­zio­ne per due volte il valore standard (16), poi due volte il valore doppio più due (34) e infine il valore è stato nuo­va­men­te rad­dop­pia­to e sommato a due (70).