# 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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-string/) è 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: ```java 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: ```java 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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/comandi-java/) `System.out.println` per l’output, otterrai questo risultato: ```java 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: ```java 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: ```java 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ì: ```java 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: ```java 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: ```java 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: ```java AFGHIJKE ``` ### `reverse()` Il metodo `reverse()` ti consente di invertire completamente la stringa memorizzata. Illustriamo anche questo metodo con un esempio pratico: ```java 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: ```java 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: ```java 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: ```java 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: ```java 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: ```java 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: ```java 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: ```java 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). This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/stringbuilder-in-java/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/stringbuilder-in-java/) for AI/LLM consumption.