Unterschied zwischen parseInt() und valueOf() in Java?

Question

Wie ist parseInt() verschieden von valueOf() ?

Für mich scheinen sie genau das Gleiche zu tun (gilt auch für parseFloat() , parseDouble() , parseLong() usw., wie unterscheiden sie sich von Long.valueOf(string) ?

Welcher dieser beiden Begriffe ist zu bevorzugen und wird üblicherweise am häufigsten verwendet?

Answer 1

• valueOf - konvertiert in Wrapper-Klasse
• parseInt - konvertiert in einen primitiven Typ

Integer.parseInt akzeptiert nur String und gibt den primitiven Integer-Typ (int) zurück.

   public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }

Iteger.valueOf akzeptiert int und String. Wenn der Wert ein String ist, konvertiert valueOf ihn mit parseInt in einen einfachen int und gibt einen neuen Integer zurück, wenn die Eingabe kleiner als -128 oder größer als 127 ist. Wenn die Eingabe im Bereich (-128 - 127) liegt, werden immer die Integer-Objekte aus einem internen IntegerCache zurückgegeben. Die Integer-Klasse unterhält eine innere statische IntegerCache-Klasse, die als Cache fungiert und Integer-Objekte von -128 bis 127 speichert. Wenn wir also versuchen, ein Integer-Objekt für 127 (zum Beispiel) zu erhalten, bekommen wir immer das gleiche Objekt.

Iteger.valueOf(200) ergibt eine neue Ganzzahl ab 200. Es ist wie new Integer(200) Iteger.valueOf(127) ist dasselbe wie Integer = 127 ;

Wenn Sie String in Integer umwandeln möchten, verwenden Sie Iteger.valueOf .

Wenn Sie String in einen einfachen int konvertieren möchten, verwenden Sie Integer.parseInt . Es funktioniert schneller.

  public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

  public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
  }

  private static class IntegerCache {
      static final int low = -128;
      static final int high;
      static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
  }

Und der Vergleich Integer.valueOf(127) == Integer.valueOf(127) ergibt true

Integer a = 127; // Compiler converts this line to Integer a = Integer.valueOf(127);
Integer b = 127; // Compiler converts this line to Integer b = Integer.valueOf(127);
a == b; // return true 

Denn es nimmt die Integer-Objekte mit denselben Referenzen aus dem Cache.

Aber Integer.valueOf(128) == Integer.valueOf(128) ist falsch, weil 128 außerhalb des IntegerCache-Bereichs liegt und ein neuer Integer zurückgegeben wird, so dass die Objekte unterschiedliche Referenzen haben werden.

Answer 2

Die parse*-Varianten geben primitive Typen zurück und die valueOf-Versionen geben Objects zurück. Ich glaube, dass die valueOf-Versionen auch einen internen Referenzpool verwenden, um das GLEICHE Objekt für einen bestimmten Wert zurückzugeben, nicht nur eine andere Instanz mit demselben internen Wert.

Answer 3

Weil Sie möglicherweise jdk1.5+ verwenden und dort ist es automatisch in int konvertieren. Also in Ihrem Code seine erste Rückkehr Integer und dann automatisch in int konvertiert.

Ihr Code ist derselbe wie

int abc = new Integer(123);

Answer 4

Wenn Sie die Klasse Integer überprüfen, werden Sie feststellen, dass valueof die Methode parseInt aufruft. Der große Unterschied ist die Zwischenspeicherung, wenn Sie die valueof-API aufrufen. Es wird zwischengespeichert, wenn der Wert zwischen -128 und 127 liegt. Weitere Informationen finden Sie unter dem folgenden Link

http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html

Answer 5

Public static Integer valueOf(String s)

1. Das Argument wird als vorzeichenbehaftete dezimale Ganzzahl interpretiert, genau so, als ob das Argument der Methode parseInt(java.lang.String) übergeben würde.

2. Das Ergebnis ist ein Integer-Objekt, das den durch die Zeichenfolge angegebenen Integer-Wert darstellt.

3. Mit anderen Worten: Diese Methode gibt ein Integer-Objekt zurück, das dem Wert von entspricht: new Integer(Integer.parseInt(s))