Java 8: l'operazione di join delle stringhe ha un impatto significativo sulle prestazioni

Question

Stavo passando per le nuove funzionalità esistenti introdotte in Java-8. Una semplice funzionalità appena aggiunta alla classe String è tranquillamente interessante per me, ovvero String Join method.

Esempio:

String.join(" ", "AZY","BAX"); // returns AZY BAX 

Per curiosità, ho controllato le prestazioni (tempo di esecuzione) di questa funzione scrivendo un codice java semplice

public static void main(String[] args) { 
    long start = System.nanoTime(); 
    String abc= String.join(" ,"AZY","BAX" … // joining 1000 words of size 3 char; 
    long diff = System.nanoTime() - start; 
    System.out.println(" Java 8 String Join " + diff); 

    start = System.nanoTime(); 
    abc= "AZY"+"BAX"+"CBA"+ … // adding 1000 word of size 3 char; 
    diff = System.nanoTime() - start; 
    System.out.println(" Tranditional " + diff); 

    start = System.nanoTime(); 
    new StringBuilder().append("AZY").append("BAX").appe… // appending 1000 word of size 3 char; 
    diff = System.nanoTime() - start; 
    System.out.println(" String Builder Append " + diff); 

} 

Il risultato non è così eccitante per me (ora in neno sec)

Java 8 String Join  1340114 
Tranditional    59785 
String Builder Append 102807 

La complessità è di o (n) - in effetti è (n * Dimensione dell'ind lunghezza elemento singolo)

Altre misure di prestazione (memoria ecc.) Non ho misurato.

Le mie domande sono:

1. qualcosa che non va nella mia misura (il più delle volte credo sui ragazzi JDK)
2. Qual è l'intento di aggiungere “join” API per classe String
3. È disponibile un'analisi delle prestazioni per Java 8

Answer 1

Per prima cosa. Questo non è il modo in cui microbench Java

Leggere prima How do I write a correct micro-benchmark in Java?. I tuoi numeri sono completamente irrilevanti, quindi lasciali ignorare.

Guardando il secondo esempio:

abc= "AZY"+"BAX"+"CBA"+... 

Questi sembrano costanti di tempo di compilazione per me. Questo String verrebbe concatenato in fase di compilazione e non ci sarebbe nulla da confrontare. Si tratta di un confronto inutile poiché l'intero punto di StringBuilder o String.join consiste nel concatenare String s che non sono costanti di tempo di compilazione.

Passare al confronto tra StringBuilder e String.join. Guardando il codice sorgente:

public static String join(CharSequence delimiter, CharSequence... elements) { 
    Objects.requireNonNull(delimiter); 
    Objects.requireNonNull(elements); 
    // Number of elements not likely worth Arrays.stream overhead. 
    StringJoiner joiner = new StringJoiner(delimiter); 
    for (CharSequence cs: elements) { 
     joiner.add(cs); 
    } 
    return joiner.toString(); 
} 

Questo utilizza un StringJoiner. Un StringJoiner utilizza semplicemente un StringBuilder sotto il cofano, quindi i due sono equivalenti.

Spesso è molto più informativo guardare al codice piuttosto che provare e confrontare le prestazioni. Anche se fai benchmark correttamente.

Vale anche la pena notare che il tuo primo metodo, con join, si aggiunge a 1000 String s su "" (spazio). Mentre il tuo metodo StringBuilder li aggiunge semplicemente insieme. Questi due non sono gli stessi.

Il punto del metodo String.join è che si può fare:

String.join(", ", "a", "b", "c") // result is "a, b, c" 

Con un StringBuilder si dovrà aggiungere un codice molto di più.