Was ist der effizienteste Weg, um ein int in einen String umzuwandeln?

Sag ich habe:

int someValue = 42;

Jetzt möchte ich diesen int-Wert in einen String konvertieren. Welcher Weg ist effizienter?

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

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

// Three
String stringValue = someValue + "";

Mich interessiert nur, ob es einen wirklichen Unterschied gibt oder einer besser ist als der andere?

testete es für 10m Zuweisungen der Nummer 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

Einer scheint zu gewinnen

Bearbeiten: JVM ist Standard ‚/usr/bin/java‘ unter Mac OS X 10.5

java version "1.5.0_16"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_16-b06-284)
Java HotSpot(TM) Client VM (build 1.5.0_16-133, mixed mode, sharing)

Mehr bearbeiten:

Code wie gewünscht

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

Fall 2 und 3 ähnlich
laufen mit

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

Auch wenn nach den Messungen von Cobbal Nr. 1 am schnellsten zu sein scheint, würde ich dringend die Verwendung von empfehlen String.valueOf(). Mein Grund dafür ist, dass dieser Aufruf den Typ des Arguments nicht explizit enthält. Wenn Sie sich also später entscheiden, ihn von int auf double zu ändern, müssen Sie diesen Aufruf nicht ändern. Der Geschwindigkeitsgewinn auf #1 im Vergleich zu #2 ist nur minimal, und wie wir alle wissen, ist „vorzeitige Optimierung die Wurzel allen Übels“.

Die dritte Lösung kommt nicht in Frage, da sie implizit a erzeugt StringBuilder und fügt die Komponenten (in diesem Fall die Zahl und die leere Zeichenfolge) daran an und konvertiert diese schließlich in eine Zeichenfolge.

Die ersten beiden Beispiele sind eigentlich identisch, da String.valueOf(int) die Methode Integer.toString(int) verwendet. Der dritte ist hässlich und wahrscheinlich weniger effizient, da die Verkettung in Java langsam ist.

Schauen Sie sich den Quellcode der JRE an und Sie werden wahrscheinlich den Unterschied sehen. Oder keine. Tatsächlich wird Strinv.valueOf(int foo) wie folgt implementiert:

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

und die Integer.toString(int foo, int radix)

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

Das heißt, wenn Sie die Basis 10 verwenden, rufen Sie die Integer.toString(int foo) besser direkt auf. Verwenden Sie für die anderen Fälle Integer.toString(int foo, int radix).

Die concat-Lösung wandelt zuerst den int-Wert in einen String um und verkettet später mit dem leeren String. Dies ist offensichtlich der teuerste Fall.

(Gegenteil von David Hanak.)

Auch wenn nach den Messungen von cobbal #1 am schnellsten zu sein scheint, würde ich dringend die Verwendung von Integer.toString() empfehlen. Mein Grund dafür ist, dass dieser Aufruf explizit den Typ des Arguments enthält. Wenn Sie sich also später entscheiden, ihn von int auf double zu ändern, ist klar, dass sich dieser Aufruf geändert hat. Sie würden dasselbe tun, wenn es ein Binärformat wäre, nicht wahr? Der Geschwindigkeitsgewinn auf #1 im Vergleich zu #2 ist nur minimal, und wie wir alle wissen, ist „vorzeitige Optimierung die Wurzel allen Übels“.

"" + int ist langsamer, wie oben von David Hanak gezeigt.

String.valueOf() wiederum Anrufe Integer.toString(). Daher verwenden Integer.toString() ist besser.

So, Integer.toString() ist am schnellsten..

Mein Micro-Benchmark-Ergebnisse für JDK 11 sind sehr unterschiedlich von denen der aktuell akzeptierten Antwort, zeigt minimaler Laufzeitunterschiedund überhaupt kein Unterschied in der Speichernutzung / -zuweisung:

 t (ms)   method

 12,30    "" + j
 12,57    Integer.toString(j)
 12.58    String.valueOf(j)

Ich habe diesen Mikrobenchmark eigentlich geschrieben, um den Juckreiz für eine andere Frage zu kratzen; Ein Kommentator schlug vor, dass ich auch hier poste. Der zu reproduzierende Code (auch aus diesem Beitrag) folgt:

package org.example;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import com.google.caliper.runner.CaliperMain;

public class Main {

    @Param({"10", "100", "1000"})
    int size;

    private String[] output;

    @BeforeExperiment
    void setUp() {
        output = new String[size];
    }

    @Benchmark void quote(int reps) {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < size; j++) {
                output[j] = "" + j;
            }
        }
    }

    @Benchmark void toString(int reps) {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < size; j++) {
                output[j] = Integer.toString(j);
            }
        }
    }

    @Benchmark void valueOf(int reps) {
        for (int i = 0; i < reps; i++) {
            for (int j = 0; j < size; j++) {
                output[j] = String.valueOf(j);
            }
        }
    }

    /*
    must have com.google.caliper:caliper:1.0-beta-3 in pom.xml; run with:
    mvn clean compile exec:java -Dexec.mainClass="com.google.caliper.runner.CaliperMain" -Dexec.args="org.example.Main"
     */
    public static void main(String[] args) {
        CaliperMain.main(Main.class, args);
    }
}