Come misura capacity() di StringBuilder?

[Gas75]

Salve,
ho notato uno strano comportamento del metodo capacity() di StringBuilder...

public class Rubrica {
	public StringBuilder name = new StringBuilder(8);
	public void mostraInfo() {
		name.append("Luca");
		name.append(" ");
		name.append("Rossi");
		System.out.println("Nome: " + name.toString());
		System.out.println("Capacita' dell'oggetto: " + name.capacity());
	}
}

Perché mi dice che la capacità è 18? Somma i dieci caratteri aggiunti agli 8 iniziali?
Anche se scrivo soltanto uno dei tre append() o non predimensiono name, ottengo valori di capacità strani...
Mi aspetterei che name avesse capacità 10 stando al codice che ho trascritto.

[andbin]

ho notato uno strano comportamento del metodo capacity() di StringBuilder...

La capacity non è il numero "logico" di caratteri (cioè la lunghezza della stringa risultante). Invece è la lunghezza fisica (arr.length) dell'array interno di char[]. StringBuffer/StringBuilder funzionano a capacità più espansa rispetto alla lunghezza logica.

Se inserendo caratteri la capacità ad un certo punto non è più sufficiente, deve essere istanziato un nuovo array char[], devono essere copiati tutti i caratteri dal vecchio al nuovo array e poi il nuovo array sostituisce quello vecchio (che finirà in pasto al garbage collector).

Il punto è che la espansione non avviene esattamente del minimo necessario ma di più. Se la capacity è 10, finché inserisci 10 caratteri, ok. Se ne inserisci ancora un altro, la capacity 10 non è più sufficiente. La classe NON rialloca a 11 ma di più.
Nel sorgente di AbstractStringBuilder (base di StringBuffer/StringBuilder), si può vedere

    void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
.....

Se capacity attuale è 10 e internamente chiede expandCapacity(11), la nuova capacity è 10*2+2 = 22.

Questo ha un grosso vantaggio: le riallocazioni non avvengono ogni momento ma solo ogni tanto. Insomma lo spreco di tempo per riallocazione-copia si dice che è "ammortizzato" nel tempo.

Le collezioni come ArrayList/Vector usano esattamente lo STESSO approccio nella gestione del loro array interno.

[Gas75]

Quindi non c'è un criterio che rende prevedibile la capacità di uno StringBuilder?
L'unico che ho notato è che se inserisco meno di 16 caratteri e non imposto una capacità iniziale, comunque ne segnala 16 che è quella di default.
Non per ripetermi ma 'ste cose ai corsi non le insegnano né stanno esplicitate sui testi. Sulle API ho dato un'occhiata ma non ho trovato...

[andbin]

Quindi non c'è un criterio che rende prevedibile la capacità di uno StringBuilder?

Certo, è quello che ho postato prima!

Sulle API ho dato un'occhiata ma non ho trovato...

Sul javadoc È ben documentato. In https://docs.oracle.com/javase/8/doc...ngBuilder.html

All'inizio spiega il concetto generale:

Every string builder has a capacity. As long as the length of the character sequence contained in the string builder does not exceed the capacity, it is not necessary to allocate a new internal buffer. If the internal buffer overflows, it is automatically made larger.

Poi per il ensureCapacity(int minimumCapacity)

Ensures that the capacity is at least equal to the specified minimum. If the current capacity is less than the argument, then a new internal array is allocated with greater capacity. The new capacity is the larger of:

The minimumCapacity argument.
Twice the old capacity, plus 2.

'ste cose ai corsi non le insegnano

Probabilmente no. Ma sta a chi studia Java avere un minimo di "iniziativa personale" per documentarsi meglio magari andando anche a sbirciare tra i sorgenti del framework.

[Gas75]

Sì scusa, sto con lo smartphone e i codici si vedono piccolissimi, come fossero delle scritte secondarie...
Grazie del link!