Quel est le moyen le plus efficace de convertir un int en une chaîne?

Question

Dis que j'ai:

 int someValue = 42;
 

Maintenant, je veux convertir cette valeur int en chaîne. De quelle façon est plus efficace?

 // One
String stringValue = Integer.toString(someValue);

// Two
String stringValue = String.valueOf(someValue);

// Three
String stringValue = someValue + "";
 

Je suis juste curieux de savoir s'il y a une réelle différence ou si l'un est meilleur que l'autre?

Answer 1

testé pour 10m assignations du nombre 10

 One:
real    0m5.610s
user    0m5.098s
sys     0m0.220s

Two:
real    0m6.216s
user    0m5.700s
sys     0m0.213s

Three:
real    0m12.986s
user    0m11.767s
sys     0m0.489s
 

L'un semble gagner

Edit: JVM est la norme '/ usr / bin / java' sous Mac OS X 10.5

version java "1.5.0_16"
Environnement d'exécution Java (TM) 2, Standard Edition (version 1.5.0_16-b06-284)
Ordinateur virtuel client Java HotSpot (TM) (version 1.5.0_16-133, mode mixte, partage)

Plus éditer:

Code à la demande

 public class One {
    public static void main(String[] args) {
        int someValue = 10;
        for (int i = 0; i < 10000000; i++) {
            String stringValue = Integer.toString(someValue);
        }
    }
}
 

cas 2 et 3 similaire
courir en utilisant

 javac *.java; time java One; time java Two; time java Three
 

Answer 2

Même si, selon les mesures de cobbal, #1 semble être le plus rapide, je recommanderais fortement l'utilisation de l' String.valueOf(). Ma raison est que cet appel ne contient pas explicitement le type de l'argument, de sorte que, si plus tard vous décidez de changer de int en double, il n'est pas nécessaire de modifier le présent appel. Le gain de vitesse sur #1 par rapport à la #2 est minime, et comme nous le savons tous, "l'optimisation prématurée est la racine de tout mal".

La troisième solution est hors de question, car il crée implicitement un StringBuilder et ajoute les composants (dans ce cas, le nombre et la chaîne vide), et enfin qui convertit une chaîne de caractères.

Answer 3

Les deux premiers exemples sont en réalité identiques, puisque String.valueOf (int) utilise la méthode Integer.toString (int). La troisième est laide et probablement moins efficace car la concaténation est lente en Java.

Answer 4

Regardez le code source de la JRE et vous aurez probablement voir la différence. Ou aucun. En fait, le Strinv.valueOf(int foo) est mis en œuvre comme suit:

public static String valueOf(int i) {
    return Integer.toString(i, 10);
}

et l'Entier.toString(int foo, int base)

public static String toString(int i, int radix) {
   ...
   if (radix == 10) {
   return toString(i);
   }
   ...
}

Ce qui signifie que si vous utilisez la base 10, il vaut mieux appeler le Entier.toString(int foo) directement. Pour les autres cas, utilisez un Entier.toString(int foo, int base).

La méthode concat tout d'abord la solution transforme la valeur int en String et, plus tard, concatène avec la Chaîne vide. Ce qui est évidemment le plus cher de l'affaire.

Answer 5

(À l'opposé de David Hanak.)

Même si, selon les mesures de cobbal, #1 semble être le plus rapide, je recommanderais fortement l'utilisation de l'Entier.toString(). Ma raison est que cet appel contient explicitement le type de l'argument, de sorte que, si plus tard vous décidez de changer de int en double, il est clair que cet appel a changé. Vous feriez la même chose si c'était un format binaire, n'est-ce pas? Le gain de vitesse sur #1 par rapport à la #2 est minime, et comme nous le savons tous, "l'optimisation prématurée est la racine de tout mal".