Integer.toString(int i) vs. String.valueOf(int i) in Java

Ich frage mich, warum die Methode String.valueOf(int i) existiert? Ich verwende diese Methode zum Konvertieren int hinein String und gerade die entdeckt Integer.toString(int i) Methode.

Nachdem ich mir die Implementierung dieser Methoden angesehen hatte, sah ich, dass die erste die zweite aufruft. Als Konsequenz alle meine Anrufe an String.valueOf(int i) einen Anruf mehr beinhalten als direkt anrufen Integer.toString(int i)

Im String-Typ haben wir mehrere Methoden valueOf

static String   valueOf(boolean b) 
static String   valueOf(char c) 
static String   valueOf(char[] data) 
static String   valueOf(char[] data, int offset, int count) 
static String   valueOf(double d) 
static String   valueOf(float f) 
static String   valueOf(int i) 
static String   valueOf(long l) 
static String   valueOf(Object obj) 

Wie wir sehen können, sind diese Methoden in der Lage, alle Arten von Zahlen aufzulösen

jede Implementierung einer bestimmten Methode, wie Sie sie vorgestellt haben: Also für ganze Zahlen haben wir

Integer.toString(int i)

für doppelt

Double.toString(double d)

usw

Meiner Meinung nach ist dies keine historische Sache, aber es ist nützlicher für einen Entwickler, die Methode zu verwenden valueOf von der String-Klasse als vom richtigen Typ, da wir weniger Änderungen vornehmen müssen, wenn wir den Typ ändern möchten, mit dem wir arbeiten.

Probe 1:

public String doStuff(int num) {

  // Do something with num...

  return String.valueOf(num);

 }

Probe2:

public String doStuff(int num) {
  
 // Do something with num...
 
 return Integer.toString(num);

 }

Wie wir in Beispiel 2 sehen, müssen wir im Gegensatz zu Beispiel 1 zwei Änderungen vornehmen.

In meiner Schlussfolgerung, mit der valueOf Methode aus der String-Klasse ist flexibler und deshalb dort verfügbar.

Ein großer Unterschied besteht darin, dass Sie aufrufen toString() in einem Null-Objekt erhalten Sie a NullPointerException während mit String.valueOf() Sie dürfen nicht auf null prüfen.

Nur zwei verschiedene Möglichkeiten, dasselbe zu tun. Es kann ein historischer Grund sein (ich kann mich nicht erinnern, ob einer vor dem anderen kam).

Die String-Klasse stellt valueOf-Methoden für alle primitiven Typen und Objekttypen bereit, daher gehe ich davon aus, dass es sich um praktische Methoden handelt, auf die alle über eine Klasse zugegriffen werden kann.

NB Profiling-Ergebnisse

Durchschnitt intToString = 5368 ms, Durchschnitt stringValueOf = 5689 ms (für 100.000.000 Operationen)

public class StringIntTest {


    public static long intToString () {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = Integer.toString(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static long stringValueOf () {

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = String.valueOf(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static void main(String[] args) {
        long intToStringElapsed = 0;
        long stringValueOfElapsed = 0;
        for (int i = 0; i < 10; i++) {
            intToStringElapsed += intToString();
            stringValueOfElapsed+= stringValueOf();
        }
        System.out.println("Average intToString = "+ (intToStringElapsed /10));
        System.out.println("Average stringValueOf = " +(stringValueOfElapsed / 10));
    }
}

Aus den Java-Quellen:

/**
 * Returns the string representation of the {@code int} argument.
 * <p>
 * The representation is exactly the one returned by the
 * {@code Integer.toString} method of one argument.
 *
 * @param   i   an {@code int}.
 * @return  a string representation of the {@code int} argument.
 * @see     java.lang.Integer#toString(int, int)
 */
public static String valueOf(int i) {
    return Integer.toString(i);
}

Sie geben also genau das gleiche Ergebnis und tatsächlich ruft das eine das andere an. String.valueOf ist flexibler, wenn Sie den Typ später ändern.

Wenn Sie sich den Quellcode für die String Klasse, es ruft tatsächlich Integer.toString() wenn du anrufst valueOf().

Davon abgesehen, Integer.toString() könnte etwas schneller sein, wenn die Methodenaufrufe zur Kompilierzeit nicht optimiert werden (was sie wahrscheinlich sind).

Die Implementierung von String.valueOf() die Sie sehen, ist der einfachste Weg, den in der API angegebenen Vertrag zu erfüllen: “Die Repräsentation ist genau diejenige, die von der zurückgegeben wird Integer.toString() Methode eines Arguments.”