Generatore di stringhe vs concatenazione di stringhe

Question

Qual è il vantaggio e il compromesso dell'uso di un generatore di stringhe sulla concatenazione di stringhe pure?

new StringBuilder(32).append(str1) 
        .append(" test: ") 
        .append(val) 
        .append(" is changed") 
        .toString(); 

vs dicono

str1 + " test: " + val + " is changed". 

str1 è una stringa di 10 caratteri casuali. str2 è una stringa casuale di 8 caratteri.

Answer 1

Nel tuo semplice esempio, nessuno perché il compilatore utilizza StringBuilder per eseguire la concatenazione di stringhe. Se la concatenazione si è verificata in un ciclo, tuttavia, il compilatore potrebbe creare diversi oggetti StringBuilder e String. Ad esempio:

String s= "" ; 
for(int i= 0 ; i < 10 ; i++) 
    s+= "a" ; 

Ogni volta che viene eseguita sopra la linea 3, viene creato un oggetto StringBuilder, il contenuto di s accodati, "a" annesso, e quindi il StringBuilder viene convertito in una stringa da assegnare ritorna s . Un totale di 10 StringBuilder se 10 String s.

Viceversa, in

StringBuilder sb= new StringBuilder() ; 
for(int i= 0 ; i < 10 ; i++) 
    sb.append("a"); 
String s= sb.toString() ; 

Solo vengono creati 1 StringBuilder e 1 String.

Il motivo principale di ciò è che il compilatore non può essere abbastanza intelligente da capire che il primo ciclo è equivalente al secondo e genera un codice più efficiente (byte). Nei casi più complessi, è impossibile sapere anche per il compilatore più intelligente. Se hai assolutamente bisogno di questa ottimizzazione, devi introdurla manualmente usando StringBuilder s in modo esplicito.

Answer 2

La risposta più immediata è la prestazione: Quando si utilizza le classi String nativi opera stringhe immutabili, che significa che quando si sta scrivendo

String line = "java"; 
    String sufix = " is awesome"; 
    line = line + sufix; 

creerà due stringhe "Java" e "è impressionante" , che creare una nuova terza stringa "java è fantastico" dai precedenti due ("java" e "è fantastico") che in seguito saranno probabilmente eliminati da un garbage collector (perché non sono più utilizzati nell'app). Questa è una soluzione lenta.

Soluzione più veloce è un'appliance della classe StringBuffer che tramite gli smart algorightms fornisce un buffer (ovvio dal suo nome) per unire le stringhe e come risultato non rimuove la stringa iniziale durante il processo di concatenazione.

Nel caso in cui si stia scrivendo un'applicazione a thread singolo (nessun problema di concurranza durante il quale più thread accedono allo stesso oggetto) è meglio applicare StringBuilder che ha prestazioni ancora più veloci rispetto alla classe StringBuffer iniziale.