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

Wie parseInt()unterscheidet sich von valueOf()?

Sie scheinen genau das Gleiche mit mir zu machen (gilt auch für parseFloat(), parseDouble(), parseLong()etc, wie unterscheiden sie sich von Long.valueOf(string)?

Welches davon ist vorzuziehen und wird konventionell häufiger verwendet?

Nun, die API für Integer.valueOf(String)sagt tatsächlich, dass das Stringgenau so interpretiert wird, als ob es gegeben wäre Integer.parseInt(String). Allerdings valueOf(String)gibt ein Objekt während kehrt ein primitive .new Integer()parseInt(String)int

Wenn Sie die potenziellen Caching-Vorteile von Integer.valueOf(int)nutzen möchten, können Sie auch diesen Schandfleck verwenden:

Integer k = Integer.valueOf(Integer.parseInt("123"))

Nun, wenn das, was Sie wollen , ist das Objekt und nicht die primitive, dann unter Verwendung von valueOf(String)möglicherweise attraktiver als zu machen , ein neues Objekt aus , parseInt(String)da erstere über durchweg vorhanden ist Integer, Long, Doubleetc.

Aus diesem Forum :

parseInt()kehrt primitiven Integer - Typen ( int ), wobei valueOfkehrt java.lang.Integer , der das Objekt repräsentativ für die ganze Zahl ist. Unter bestimmten Umständen möchten Sie möglicherweise ein Integer-Objekt anstelle eines primitiven Typs.

Ein weiterer offensichtlicher Unterschied besteht natürlich darin, dass intValue eine Instanzmethode ist, bei der parseInt eine statische Methode ist.

Integer.valueOf(s)

ist ähnlich wie

new Integer(Integer.parseInt(s))

Der Unterschied ist valueOf()ein Integerund parseInt()ein int(ein primitiver Typ). Beachten Sie auch, dass valueOf()eine zwischengespeicherte IntegerInstanz zurückgegeben werden kann, was zu verwirrenden Ergebnissen führen kann, wenn das Testergebnis ==zeitweise korrekt erscheint. Vor dem Autoboxen kann es einen Unterschied in der Benutzerfreundlichkeit geben, nach Java 1.5 spielt es keine Rolle mehr.

Darüber hinaus Integer.parseInt(s)kann auch primitiver Datentyp verwendet werden.

Schauen Sie sich Java-Quellen an: valueOfverwendet parseInt:

/**
 * Parses the specified string as a signed decimal integer value.
 *
 * @param string
 *            the string representation of an integer value.
 * @return an {@code Integer} instance containing the integer value
 *         represented by {@code string}.
 * @throws NumberFormatException
 *             if {@code string} cannot be parsed as an integer value.
 * @see #parseInt(String)
 */
public static Integer valueOf(String string) throws NumberFormatException {
    return valueOf(parseInt(string));
}

parseInt kehrt zurück int

/**
 * Parses the specified string as a signed decimal integer value. The ASCII
 * character \u002d ('-') is recognized as the minus sign.
 *
 * @param string
 *            the string representation of an integer value.
 * @return the primitive integer value represented by {@code string}.
 * @throws NumberFormatException
 *             if {@code string} cannot be parsed as an integer value.
 */
public static int parseInt(String string) throws NumberFormatException {
    return parseInt(string, 10);
}

Integer.parseInt kann nur int als nativen Typ zurückgeben.

Integer.valueOf muss möglicherweise tatsächlich ein Integer-Objekt zuweisen, es sei denn, diese Ganzzahl ist eine der vorab zugewiesenen. Das kostet mehr.

Wenn Sie nur einen nativen Typ benötigen, verwenden Sie parseInt. Wenn Sie ein Objekt benötigen, verwenden Sie valueOf.

Aufgrund dieser möglichen Zuordnung ist Autoboxing nicht in jeder Hinsicht eine gute Sache. Es kann Dinge verlangsamen.

Die parse * -Variationen geben primitive Typen zurück und die valueOf-Versionen geben Objekte 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 für eine andere Instanz mit demselben internen Wert.

Da Sie möglicherweise jdk1.5 + verwenden und es dort automatisch in int konvertiert wird. In Ihrem Code wird also zuerst eine Ganzzahl zurückgegeben und dann automatisch in int konvertiert.

Ihr Code ist der gleiche wie

int abc = new Integer(123);

Wenn Sie die Integer-Klasse überprüfen, finden Sie den Wert der Methode parseInt. Der große Unterschied besteht im Caching, wenn Sie valueof API aufrufen. Es wird zwischengespeichert, wenn der Wert zwischen -128 und 127 liegt. Weitere Informationen finden Sie unter dem Link

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

public static Integer valueOf (String s)

1. Das Argument wird so interpretiert, dass es eine vorzeichenbehaftete Dezimalzahl darstellt, genau so, als ob das Argument an die 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: new Integer (Integer.parseInt (s)) entspricht.

• valueOf - konvertiert in die Wrapper-Klasse
• parseInt - konvertiert in 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 akzeptiere int und String. Wenn value String ist, konvertieren Sie valueOf mit parseInt in das einfache int und geben Sie eine neue Ganzzahl 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 von a zurückgegeben interner IntegerCache. Die Integer-Klasse verwaltet eine innere statische IntegerCache-Klasse, die als Cache fungiert und Integer-Objekte von -128 bis 127 enthält. Wenn wir beispielsweise versuchen, ein Integer-Objekt für 127 abzurufen, erhalten wir immer dasselbe Objekt.

Iteger.valueOf(200)wird neue Ganzzahl von 200 geben. Es ist wie new Integer(200) Iteger.valueOf(127)das gleiche wie Integer = 127;

Wenn Sie String nicht in die Ganzzahl konvertieren möchten, verwenden Sie Iteger.valueOf.

Wenn Sie String nicht in das einfache 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() {}
  }

Ein Vergleich von 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 

Weil es die Integer-Objekte mit den gleichen Referenzen aus dem Cache nimmt.

Integer.valueOf (128) == Integer.valueOf (128) ist jedoch falsch, da 128 außerhalb des IntegerCache-Bereichs liegt und neue Integer zurückgibt, sodass Objekte unterschiedliche Referenzen haben.

1. Bei ValueOf -> wird ein Integer-Objekt erstellt. kein primitiver Typ und keine statische Methode.
2. Im Fall von ParseInt.ParseFloat -> wird der jeweilige primitive Typ zurückgegeben. und ist eine statische Methode.

Wir sollten je nach Bedarf einen verwenden. Im Fall von ValueOf, da es ein Objekt instanziiert. Es wird mehr Ressourcen verbrauchen, wenn wir nur den Wert eines Textes benötigen, dann sollten wir parseInt, parseFloat usw. verwenden.