Quel type de guillemet est plus efficace?

Question

Juste curieux, ce qui est plus efficace?

Ce:

String a = someString + "." + anotherString; 

Ou ceci:

String a = someString + '.' + anotherString; 

Answer 1

Ils sont assez similaires. '.' est légèrement plus rapide, mais la différence est négligeable (environ 20 ms dans une boucle de 10 millions).

Voici mon test:

$cat UsingC.java UsingS.java 
public class UsingC { 
    public static void main(String [] args) { 
     String someString = ""; 
     String anotherString = ""; 

     int i = 0; 
     while(i++ < 10000000) { 
      String a = someString + '.' + anotherString; 
     } 
    } 
} 
public class UsingS{ 
    public static void main(String [] args) { 
     String someString = ""; 
     String anotherString = ""; 

     int i = 0; 
     while(i++ < 10000000) { 
      String a = someString + "." + anotherString; 
     } 
    } 
} 
$for i in 1 2 3 4 5 ; do time java UsingC; done 

real 0m1.643s 
user 0m1.424s 
sys 0m0.108s 

real 0m1.670s 
user 0m1.468s 
sys 0m0.056s 

real 0m2.023s 
user 0m1.448s 
sys 0m0.080s 

real 0m1.669s 
user 0m1.432s 
sys 0m0.088s 

real 0m1.674s 
user 0m1.416s 
sys 0m0.104s 
$for i in 1 2 3 4 5 ; do time java UsingS; done 

real 0m2.344s 
user 0m1.584s 
sys 0m0.136s 

real 0m2.057s 
user 0m1.640s 
sys 0m0.084s 

real 0m2.112s 
user 0m1.732s 
sys 0m0.072s 

real 0m2.482s 
user 0m1.704s 
sys 0m0.108s 

real 0m2.134s 
user 0m1.788s 
sys 0m0.072s 

Vous pouvez faire une moyenne et/ou créer un test plus complexe.

Ils utilisent tous deux StringBuilder de manière interne.

Answer 2

Vous devriez vraiment pas de soins, à moins que cela est tout ce que vous faites, des milliers de fois par seconde, pendant plusieurs heures.

La rumeur veut que l'utilisation d'un StringBuilder soit la plus rapide. Essayez-les tous les deux, en boucle, un million de fois, et consignez le temps que cela prend, puis retournez nous au reste d'entre nous.

Answer 3

Le compilateur Java transformera toute expression de concaténation de chaîne en une séquence équivalente d'opérations StringBuilder. Il est prudent de supposer que la séquence sera proche de l'optimum. En effet, dans cet exemple particulier, je m'attendrais à ce que la même séquence (optimale) soit générée dans les deux cas. Mais même si ce n'est pas le cas, la différence risque d'être faible.

Cela ne vaut la peine de se soucier de ce genre de choses que si le profileur vous dit qu'une instruction particulière est un goulot d'étranglement dans votre code. L'optimisation prématurée est inutile (au mieux) et peut même être nuisible.

L'avis des Sun est que le code Java optimisé à la main peut être un code plus lent car la séquence de bytecode résultante devient trop complexe pour que le compilateur JIT puisse optimiser correctement. Le meilleur conseil est simplement d'écrire le code simplement et faire confiance aux compilateurs Javac et JIT pour faire du bon travail.

Answer 4

En regardant le code pour StringBuilder.append et AbstractStringBuilder.append, je voudrais attendre le '.' former pour être plus rapide.

Il a moins à faire, essentiellement:

• Il n'a pas besoin de faire une vérification de nullité, que le charbon ne peut être nul
• Il ne cherche pas à faire une optimisation pour un vide chaîne soit
• il n'a pas besoin de chercher la longueur à ajouter - il sera toujours 1
• il n'a qu'à effectuer une seule cession dans le tableau plutôt qu'une seule boucle itération

Comme tout le monde cependant, je ne m'attendrais pas à ce que la différence soit significative dans le vrai code d'application.

Je ne sais pas s'il serait valable pour le compilateur Java de réaliser que ce qui est en train d'être ajouté est une chaîne constante de longueur 1, et de la convertir en caractère littéral à la place - ou si cela dérangerait même si ce serait valide.