StringBuilder în Java

Un text care se poate modifica pe loc: adaugi, inserezi și ștergi fără să creezi un șir nou la fiecare pas.

Sintaxă
public final class StringBuilder implements CharSequence, Comparable<StringBuilder>
new StringBuilder()
new StringBuilder(String inceput)
int length()
void setLength(int lungimeNoua)
String toString()

Ce face StringBuilder

Un String nu se poate modifica. Când lipești text în multe etape (de exemplu într-o buclă), fiecare + creează un șir nou. StringBuilder păstrează textul într-o zonă de memorie care crește singură, iar metode ca append, insert sau delete îl modifică direct.

length() dă numărul de caractere de acum. setLength(n) schimbă lungimea: dacă n este mai mic, textul se taie; dacă este mai mare, se completează cu caracterul '\u0000'. setLength(0) golește constructorul ca să îl refolosești.

La final apelezi toString(), care returnează un String obișnuit, o copie a conținutului. Modificările ulterioare ale constructorului nu mai schimbă șirul obținut. StringBuilder nu este sigur pentru mai multe fire de execuție; pentru asta există clasa mai veche StringBuffer.

Parametri

Parametru Descriere
inceput Textul cu care pornește constructorul (opțional).
lungimeNoua Pentru setLength: noua lungime, cel puțin 0.

Ce returnează

length(): numărul de caractere. toString(): un String nou cu conținutul curent. setLength nu returnează nimic.

Exemple

Exemplul 1: Construirea unei liste de cumpărături

Metodele append se pot înlănțui, pentru că fiecare returnează același obiect StringBuilder.

public class Main {
    public static void main(String[] args) {
        String[] produse = {"pâine", "lapte", "mere"};
        StringBuilder sb = new StringBuilder("Cumpărături: ");
        for (int i = 0; i < produse.length; i++) {
            if (i > 0) {
                sb.append(", ");
            }
            sb.append(produse[i]);
        }
        sb.append('.');
        String lista = sb.toString();
        System.out.println(lista);
        System.out.println("Lungime: " + sb.length());
    }
}

Rezultat

Cumpărături: pâine, lapte, mere.
Lungime: 32

Exemplul 2: setLength: tăierea și golirea textului

setLength(0) golește constructorul; poți folosi același obiect pentru rândul următor.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Maria Ionescu");
        sb.setLength(5);
        System.out.println("[" + sb + "] " + sb.length());

        String[] orase = {"Iași", "Suceava"};
        for (String oras : orase) {
            sb.setLength(0);
            sb.append("Oraș: ").append(oras).append(" (").append(oras.length()).append(" litere)");
            System.out.println(sb);
        }
    }
}

Rezultat

[Maria] 5
Oraș: Iași (4 litere)
Oraș: Suceava (7 litere)

Exemplul 3: toString face o copie

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Nota 9");
        String salvat = sb.toString();
        sb.append(" (corectată: 10)");
        System.out.println(salvat);
        System.out.println(sb.toString());
    }
}

Rezultat

Nota 9
Nota 9 (corectată: 10)

Greșeli frecvente

  • Compari un StringBuilder cu un șir folosind equals: sb.equals("abc") este mereu false. Compară sb.toString().equals("abc") sau folosește "abc".contentEquals(sb).
  • Folosești += pe un String într-o buclă mare. Merge, dar este lent; StringBuilder este gândit exact pentru asta.
  • Uiți că setLength cu o valoare mai mare adaugă caractere '\u0000' invizibile, nu spații.

Comenzi înrudite

  • StringBuilder.append: Adaugă la sfârșitul textului un șir, un caracter, un număr sau orice obiect și returnează același StringBuilder.
  • StringBuilder.insert: Inserează un text sau o valoare la o poziție dată; caracterele de după poziție se mută spre dreapta.
  • StringBuilder.delete: delete() șterge caracterele dintre două poziții, deleteCharAt() șterge un singur caracter.
  • String: Clasa pentru text în Java: un șir de caractere care nu se mai poate modifica după ce a fost creat.
  • String.join: Lipește mai multe șiruri într-unul singur, cu un separator între ele (opusul lui split).