Diferente entre parseInt () e valueOf () em java?

Qual é a parseInt()diferença valueOf()?

Eles parecem fazer exatamente a mesma coisa para mim (também vale para parseFloat(), parseDouble(), parseLong()etc, como eles são diferentes de Long.valueOf(string)?

Além disso, qual deles é preferível e usado com mais frequência por convenção?

Bem, a API para Integer.valueOf(String)realmente diz que o Stringé interpretado exatamente como se fosse fornecido Integer.parseInt(String). No entanto, valueOf(String)retorna um objeto enquanto retorna um primitivo .new Integer()parseInt(String)int

Se você quiser aproveitar os benefícios potenciais de armazenamento em cache Integer.valueOf(int), também poderá usar esta tristeza:

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

Agora, se o que você quer é o objeto e não o primitivo, em seguida, usando valueOf(String)pode ser mais atraente do que fazer um novo objeto para fora do parseInt(String)porque o primeiro é consistentemente presentes em Integer, Long, Double, etc.

Deste fórum :

parseInt()retorna o tipo inteiro primitivo ( int ), pelo qual valueOfretorna java.lang.Integer , que é o objeto representativo do número inteiro. Há circunstâncias em que você pode querer um objeto Inteiro, em vez do tipo primitivo.

Obviamente, outra diferença óbvia é que intValue é um método de instância pelo qual parseInt é um método estático.

Integer.valueOf(s)

é similar a

new Integer(Integer.parseInt(s))

A diferença é valueOf()retorna um Integere parseInt()retorna um int(um tipo primitivo). Observe também que valueOf()pode retornar uma Integerinstância em cache , o que pode causar resultados confusos onde o resultado dos ==testes parece intermitentemente correto. Antes da autoboxing , poderia haver uma diferença de conveniência, depois do java 1.5, isso realmente não importa.

Além disso, também Integer.parseInt(s)pode levar tipos de dados primitivos.

Veja fontes Java: valueOfestá usando 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 retorna 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 pode retornar apenas int como tipo nativo.

O inteiro.valueOf pode realmente precisar alocar um objeto inteiro, a menos que esse inteiro seja um dos pré-alocados. Isso custa mais.

Se você precisar apenas do tipo nativo, use parseInt. Se você precisar de um objeto, use valueOf.

Além disso, devido a essa alocação em potencial, a autoboxing não é realmente boa em todos os aspectos. Pode retardar as coisas.

As variações de análise * retornam tipos primitivos e as versões valueOf retornam Objetos. Acredito que as versões valueOf também usarão um pool de referência interno para retornar o mesmo objeto para um determinado valor, não apenas outra instância com o mesmo valor interno.

Porque você pode estar usando o jdk1.5 + e lá está a conversão automática para int. Portanto, no seu código, é o primeiro inteiro que retorna e depois é convertido automaticamente em int.

seu código é o mesmo que

int abc = new Integer(123);

Se você marcar a classe Integer, encontrará o valor da chamada parseInt. A grande diferença é o armazenamento em cache quando você chama o valor da API. Ele armazena em cache se o valor estiver entre -128 e 127. Encontre abaixo o link para obter mais informações.

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

public static Número inteiro valueOf (String s)

1. O argumento é interpretado como representando um número inteiro decimal assinado, exatamente como se o argumento tivesse sido fornecido para o método parseInt (java.lang.String).

2. O resultado é um objeto Inteiro que representa o valor inteiro especificado pela sequência.

3. Em outras palavras, esse método retorna um objeto Inteiro igual ao valor de: new Inteiro (Integer.parseInt (s))

• valueOf - converte na classe Wrapper
• parseInt - converte em tipo primitivo

Integer.parseInt aceita apenas String e retorna o tipo inteiro primitivo (int).

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

Iteger.valueOf aceita int e String. Se value for String, valueOf converta-o para o int simples usando parseInt e retorne novo Inteiro se a entrada for menor que -128 ou maior que 127. Se a entrada estiver no intervalo (-128 - 127), sempre retornará os objetos Inteiros de um IntegerCache interno. A classe integer mantém uma classe IntegerCache estática interna que atua como cache e mantém objetos inteiros de -128 a 127 e é por isso que quando tentamos obter um objeto inteiro para 127 (por exemplo), sempre obtemos o mesmo objeto.

Iteger.valueOf(200)dará um novo número inteiro de 200. É como new Integer(200) Iteger.valueOf(127)é o mesmo que Integer = 127;

Se você não converter a String para o número inteiro, use Iteger.valueOf.

Se você não converter o String no simples int use Integer.parseInt. Funciona mais rápido.

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

E comparando Integer.valueOf (127) == Integer.valueOf (127) retorna 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 

Porque ele leva os objetos Inteiros com as mesmas referências do cache.

Mas Integer.valueOf (128) == Integer.valueOf (128) é falso, porque 128 está fora do intervalo IntegerCache e retorna um novo Integer, portanto, os objetos terão referências diferentes.

1. No caso de ValueOf ->, ele está criando um objeto Inteiro. não é um tipo primitivo e não é um método estático.
2. No caso de ParseInt.ParseFloat ->, ele retorna o respectivo tipo primitivo. e é um método estático.

Devemos usar qualquer um, dependendo da nossa necessidade. No caso de ValueOf, ele está instanciando um objeto. consumirá mais recursos se precisarmos apenas de algum texto, então devemos usar parseInt, parseFloat etc.