Diferença entre parseInt e valueOf em java?

Qual a diferença entre esses dois methods? 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) ?

Edit: Além disso, qual deles é preferível e usado mais frequentemente por convenção?

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

Se você quiser aproveitar os possíveis benefícios de cache do Integer.valueOf(int) , você também pode usar esta monstruosidade:

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

Agora, se o que você quer é o object e não o primitivo, usar valueOf(String) pode ser mais atraente do que criar um novo object fora de parseInt(String) porque o primeiro está consistentemente presente em Integer , Long , Double , etc.

Deste fórum :

parseInt() retorna um tipo de inteiro primitivo ( int ), pelo qual valueOf retorna java.lang.Integer , que é o object representativo do inteiro. Há circunstâncias em que você pode querer um object Integer, em vez de um tipo primitivo.

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

 Integer.valueOf(s) 

é similar a

 new Integer(Integer.parseInt(s)) 

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

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

Veja as fonts do Java: valueOf está 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 apenas retornar int como tipo nativo.

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

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

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

Porque você pode estar usando jdk1.5 + e lá está convertendo automaticamente para int. Então, no seu código, o primeiro inteiro retornando e depois convertido automaticamente para int.

seu código é o mesmo que

 int abc = new Integer(123); 

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

Já que valueOf retorna um novo object Integer porque o código abaixo está correto?

 String base5String = "230"; int result = Integer.valueOf(base5String); 

Se você verificar a class Integer, encontrará o valor do método parseInt de chamada. A grande diferença é o armazenamento em cache quando você chama o valor da API. Cache se o valor estiver entre -128 e 127. Veja abaixo o link para mais informações

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

public static inteiro valorOf (String s)

  1. O argumento é interpretado como representando um inteiro decimal com sinal, exatamente como se o argumento fosse dado ao método parseInt (java.lang.String).
  2. O resultado é um object Integer que representa o valor inteiro especificado pela string.

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

  1. No caso de ValueOf -> ele está criando um object Integer. 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 como está instanciando um object. consumirá mais resources se precisarmos apenas de algum valor, então devemos usar parseInt, parseFloat etc.