Quante stringhe vengono create in memoria durante la concatenazione di stringhe in Java?

Mi è stato chiesto delle stringhe immutabili in Java. Mi è stato assegnato il compito di scrivere una funzione che concatenasse un numero di "a" s in una stringa.

Cosa ho scritto:

public String foo(int n) {
    String s = "";
    for (int i = 0; i < n; i++) {
        s = s + "a"
    }
    return s;
}

Mi è stato poi chiesto quante stringhe questo programma avrebbe generato, supponendo che la raccolta dei rifiuti non avvenga. I miei pensieri per n = 3 erano

1. ""
2. "un"
3. "un"
4. "aa"
5. "un"
6. "Aaa"
7. "un"

Essenzialmente vengono create 2 stringhe in ogni iterazione del ciclo. Tuttavia, la risposta era n ² . Quali stringhe verranno create in memoria da questa funzione e perché è così?

Mi è stato poi chiesto quante stringhe questo programma avrebbe generato, supponendo che la raccolta dei rifiuti non avvenga. I miei pensieri per n = 3 erano (7)

Le stringhe 1 ( "") e 2 ( "a") sono le costanti nel programma, non sono create come parte delle cose ma vengono "internate" perché sono costanti di cui il compilatore conosce. Maggiori informazioni al riguardo sono disponibili su String interning su Wikipedia.

Ciò rimuove anche le stringhe 5 e 7 dal conteggio poiché sono le stesse della "a"stringa n. 2. Questo lascia le stringhe # 3, # 4 e # 6. La risposta è "3 stringhe vengono create per n = 3" usando il tuo codice.

Il conteggio di n ² è ovviamente errato perché in n = 3, questo sarebbe 9 e anche dalla risposta nel caso peggiore, che era solo 7. Se le stringhe non internate fossero corrette, la risposta avrebbe dovuto essere 2n + 1.

Quindi, la domanda su come dovresti farlo?

Poiché la stringa è immutabile , vuoi qualcosa di mutabile, qualcosa che puoi cambiare senza creare nuovi oggetti. Questo è StringBuilder .

La prima cosa da guardare sono i costruttori. In questo caso sappiamo quanto tempo sarà la stringa e c'è un costruttore StringBuilder(int capacity) che significa che allociamo esattamente tutto ciò di cui abbiamo bisogno.

Successivamente, "a"non deve essere una stringa , ma può piuttosto essere un personaggio 'a'. Questo ha un piccolo miglioramento delle prestazioni quando si chiama append(String)vs append(char)- con il append(String), il metodo deve scoprire quanto è lunga la String e fare un po 'di lavoro su questo. D'altra parte, charè sempre esattamente lungo un personaggio.

Le differenze di codice sono visibili in StringBuilder.append (String) vs StringBuilder.append (char) . Non è qualcosa di cui preoccuparsi troppo , ma se stai cercando di impressionare il datore di lavoro è meglio usare le migliori pratiche possibili.

Quindi, come appare quando lo metti insieme?

public String foo(int n) {
    StringBuilder sb = new StringBuilder(n);
    for (int i = 0; i < n; i++) {
        sb.append('a');
    }
    return sb.toString();
}

Sono stati creati uno StringBuilder e uno String. Non è necessario internare stringhe extra.

Scrivi alcuni altri semplici programmi in Eclipse. Installa pmd ed eseguilo sul codice che scrivi. Nota di cosa si lamenta e risolvi queste cose. Avrebbe trovato la modifica di una stringa con + in un ciclo e se l'avessi modificata in StringBuilder, avrebbe forse trovato la capacità iniziale, ma avrebbe sicuramente colto la differenza tra .append("a")e.append('a')

Ad ogni iterazione, un nuovo Stringviene creato +dall'operatore e assegnato a s. Dopo il ritorno, tutti tranne l'ultimo vengono raccolti.

Le costanti di stringa gradiscono ""e "a"non vengono create ogni volta, si tratta di stringhe internate . Poiché le stringhe sono immutabili, possono essere liberamente condivise; questo succede alle costanti di stringa.

Per concatenare in modo efficiente le stringhe, utilizzare StringBuilder.

Come spiega MichaelT nella sua risposta, il codice alloca stringhe O (n). Ma alloca anche O (n ² ) byte di memoria e viene eseguito nel tempo O (n ² ).

Alloca O (n ² ) byte, perché le stringhe che stai allocando hanno lunghezze 0, 1, 2,…, n-1, n, che si somma a (n ² + n) / 2 = O (n ² ).

Il tempo è anche O (n ² ), perché l'allocazione della stringa i-esima richiede la copia della stringa (i-1), che ha lunghezza i-1. Ciò significa che ogni byte allocato deve essere copiato, il che richiederà tempo O (n ² ).

Forse è questo che intendevano gli intervistatori?