Java 8 : Chaîne de se joindre à l'opération a d'impact significatif sur les performances

Je passais par le nouvellement ajouté existant fonctionnalités introduites dans Java 8.
Une simple fonctionnalité récemment ajoutée à la classe String est calme attrayant pour moi – c'est-à Chaîne de Rejoindre méthode.

Exemple:

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

Pour la curiosité, j'ai vérifié les performances (temps d'exécution) de cette fonction par l'écriture d'un simple code java

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);

}

Le résultat n'est pas si excitant pour moi (de temps en neno sec)

Java 8 String Join     1340114
Tranditional             59785
String Builder Append   102807

La complexité est de o(n) en fait, c'est de (n * Taille de l'élément individuel de la longueur)

D'autres mesures de performance (mémoire, etc) je n'ai pas mesuré.

Mes questions sont:

  1. Il n'y a rien de mal dans ma mesure (la plupart du temps, je crois que sur le jdk gars)
  2. Quelle est l'intention de l'ajout de “rejoindre” l'API de la classe String
  3. Est-il de toute analyse de la performance pour Java 8 est disponible
L'écriture correcte de référence en Java n'est pas si simple, parce que le JIT heuristiques et de collecte des ordures. Voir Comment puis-je écrire un bon micro-benchmark en Java?.
Par curiosité, pourquoi aurait-on utiliser cette méthode au lieu de +?
Aussi, la concaténation de chaînes de caractères littérales se fait au moment de la compilation, de sorte que vous n'êtes pas vraiment tester quoi que ce soit dans le deuxième test.
Merci Jesper.. Kishan.. Sa ma copier/coller miste... Il convient de Chaîne abc= String.join(" ","AZY" ...
le code n'est même pas équivalent, la jointure a le délimiteur alors que le traditionnel et stringbuilder ne le font pas.

OriginalL'auteur dgm | 2014-06-05

  1. 43

    Premières choses d'abord. Ce n'est pas la façon dont vous microbench Java

    Lire Comment puis-je écrire un bon micro-benchmark en Java? premier. Vos chiffres sont totalement inutiles, donc permet de les ignorer.

    Regardant le deuxième exemple:

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

    Ressemblent à compiler les constantes de temps pour moi. Cette String serait concaténé au moment de la compilation et il n'y aurait rien de référence. C'est inutile de comparaison que le point de l'ensemble de la StringBuilder ou String.join est de concaténer Strings qui ne sont pas compiler constante de temps.

    De passer en comparant les StringBuilder et String.join. En regardant le code source:

    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();
}

    Il utilise un StringJoiner. Un StringJoiner utilise simplement un StringBuilder sous le capot, de sorte que les deux sont équivalents.

    Il est souvent beaucoup plus instructif de regarder au code que d'essayer de performance de référence. Même si vous faites référence correctement.

    Il est également intéressant de noter que la première méthode, avec join, se joint à l'1000 Strings sur "" (espace). Alors que votre StringBuilder méthode ajoute simplement ensemble. Ces deux ne sont pas les mêmes.

    Le point de la String.join méthode est que vous pouvez faire:

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

    Avec un StringBuilder vous serait d'ajouter beaucoup plus de code.

    A cette question, il ne cherche pas à l'indice de référence de Java. mais pour comprendre l'intention de "se joindre" de l'API. (Je pense que c'est clair à partir de ces questions). Je ne suis pas encore sûr de savoir pourquoi nous avons besoin d'une API qui ne boucle imbriquée (un String.jave - méthode join() comme vous l'avez dit, qui en interne appelez append() la méthode de AbstractStringBuilder) au lieu d'utiliser StringBuilder directement
    parce que le point de Java 8 est d'ajouter des méthodes qui permettent d'éviter explicite en boucle et à l'utilisation plus fonctionnelle paradigmes. String.join est censé être un raccourci pour Stream.of(a, b, c).collect(Collectors.joining()). Si vous ne voyez pas les avantages d'autoriser les utilisateurs à se joindre à un String en une seule ligne de code plutôt que 4, alors il suffit de ne pas l'utiliser...
    bien sûr, c'est la JVM de personnes à charge c'est d'Oracle. La mise en œuvre serait la même pour OpenJDK, je suppose. L'algorithme juste réutilise le StringJoiner de le rejoindre Collector de la Stream API. Si vous avez vraiment besoin de faire sortir plus de performances, alors vous pourriez faire ce que vous dites.
    Il y a une autre différence. String.join est un varargs méthode qui implique avant même le début de ses travaux, un tableau temporaire est créé et rempli avec tous les 1000 String une référence en la StringBuilder équivalent dans la question des appels append 1000 fois.
    Je ne comprends pas votre question @RomanG. Comme je l'ai dit un StringJoiner utilise un StringBuilder pour faire le travail.

    OriginalL'auteur