Différent entre parseInt () et valueOf () en java?

En quoi est-ce parseInt()différent devalueOf() ?

Ils semblent faire exactement pour moi la même chose (va aussi parseFloat(), parseDouble(), parseLong()etc, comment sont - ils différents Long.valueOf(string)?

De plus, lequel de ceux-ci est préférable et utilisé le plus souvent par convention?

Eh bien, l'API pour en Integer.valueOf(String)effet dit que le Stringest interprété exactement comme s'il était donné à Integer.parseInt(String). Cependant, valueOf(String)renvoie un objet alors que renvoie une primitivenew Integer()parseInt(String)int .

Si vous souhaitez profiter des avantages potentiels de la mise en cache Integer.valueOf(int), vous pouvez également utiliser cette horreur:

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

Maintenant, si ce que vous voulez est l'objet et non la primitive, puis en utilisant valueOf(String)peut - être plus attrayant que de faire un nouvel objet sur parseInt(String)parce que le premier est toujours présent à travers Integer, Long, Double, etc.

De ce forum :

parseInt()renvoie le type entier primitif ( int ), ce qui valueOfrenvoie java.lang.Integer , qui est l'objet représentatif de l'entier. Dans certains cas, vous souhaiterez peut-être un objet Integer au lieu d'un type primitif.

Bien sûr, une autre différence évidente est que intValue est une méthode d'instance où parseInt est une méthode statique.

Integer.valueOf(s)

est similaire à

new Integer(Integer.parseInt(s))

La différence est valueOf()renvoie un Integeret parseInt()retourne un int(un type primitif). Notez également que valueOf()peut renvoyer une Integerinstance mise en cache , ce qui peut entraîner des résultats confus lorsque le résultat des ==tests semble correct par intermittence. Avant l' autoboxing il pourrait y avoir une différence de commodité, après Java 1.5, cela n'a pas vraiment d'importance.

De plus, Integer.parseInt(s)peut également prendre le type de données primitif.

Regardez les sources Java: valueOfutilise 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 Retour 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 peut simplement retourner int comme type natif.

Integer.valueOf peut en fait avoir besoin d'allouer un objet Integer, sauf si cet entier se trouve être l'un des objets préalloués. Cela coûte plus cher.

Si vous avez juste besoin d'un type natif, utilisez parseInt. Si vous avez besoin d'un objet, utilisez valueOf.

De plus, en raison de cette allocation potentielle, la mise en boîte automatique n'est pas vraiment une bonne chose à tous points de vue. Cela peut ralentir les choses.

Les variantes parse * renvoient des types primitifs et les versions valueOf renvoient des objets. Je crois que les versions valueOf utiliseront également un pool de référence interne pour renvoyer l'objet SAME pour une valeur donnée, pas seulement une autre instance avec la même valeur interne.

Parce que vous utilisez peut-être jdk1.5 + et qu'il est automatiquement converti en int. Ainsi, dans votre code, il renvoie son premier Integer puis est automatiquement converti en int.

votre code est le même que

int abc = new Integer(123);

Si vous cochez la classe Integer, vous trouverez cette valeur de la méthode call parseInt. La grande différence est la mise en cache lorsque vous appelez valueof API. Il cache si la valeur est comprise entre -128 et 127 Veuillez trouver ci-dessous le lien pour plus d'informations

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

public static Integer valueOf (String s)

1. L'argument est interprété comme représentant un entier décimal signé, exactement comme si l'argument était donné à la méthode parseInt (java.lang.String).

2. Le résultat est un objet Integer qui représente la valeur entière spécifiée par la chaîne.

3. En d'autres termes, cette méthode renvoie un objet Integer égal à la valeur de: new Integer (Integer.parseInt (s))

• valueOf - convertit en classe Wrapper
• parseInt - convertit en type primitif

Integer.parseInt n'accepte que String et retourne le type entier primitif (int).

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

Iteger.valueOf accepte int et String. Si la valeur est String, valueOf la convertit en simple int à l'aide de parseInt et renvoie un nouvel entier si l'entrée est inférieure à -128 ou supérieure à 127. Si l'entrée est dans la plage (-128 - 127), elle renvoie toujours les objets Integer à partir d'un IntegerCache interne. La classe Integer maintient une classe IntegerCache statique interne qui agit comme cache et contient les objets entiers de -128 à 127 et c'est pourquoi lorsque nous essayons d'obtenir un objet entier pour 127 (par exemple), nous obtenons toujours le même objet.

Iteger.valueOf(200)donnera un nouvel Integer à partir de 200. C'est comme new Integer(200) Iteger.valueOf(127)est le même que Integer = 127;

Si vous ne convertissez pas String en entier, utilisez-le Iteger.valueOf.

Si vous ne voulez pas convertir String en simple int Integer.parseInt. Ça marche plus vite.

  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() {}
  }

Et en comparant Integer.valueOf (127) == Integer.valueOf (127) renvoie 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 

Parce qu'il prend les objets Integer avec les mêmes références du cache.

Mais Integer.valueOf (128) == Integer.valueOf (128) est faux, car 128 est hors de la plage IntegerCache et il renvoie un nouvel Integer, donc les objets auront des références différentes.

1. Dans le cas de ValueOf -> il crée un objet Integer. pas un type primitif et pas une méthode statique.
2. Dans le cas de ParseInt.ParseFloat -> il retourne le type primitif respectif. et est une méthode statique.

Nous devons en utiliser un en fonction de nos besoins. En cas de ValueOf car il instancie un objet. cela consommera plus de ressources si nous n'avons besoin que de la valeur d'un texte, alors nous devrions utiliser parseInt, parseFloat etc.