不同的parseInt()和valueOf()在java?

从这个论坛:

parseInt()返回原始整数 类型(int)，其中valueOf返回 java.lang.Integer，这是对象 整数的代表。在那里 是你想要的环境吗 一个Integer对象，而不是 原始类型。< / p > 当然，还有一个明显的区别 intValue是一个实例方法吗 其中方法用于是一个静态方法

Integer.valueOf(s)

类似于

new Integer(Integer.parseInt(s))

区别在于valueOf()返回Integer，而parseInt()返回int(基本类型)。还要注意，valueOf()可以返回缓存的Integer实例，这可能会导致令人困惑的结果，其中==测试的结果似乎间歇性正确。在自动装箱之前，便利性可能会有所不同，在java 1.5之后，这并不重要。

此外，Integer.parseInt(s)也可以接受基本数据类型。

parse*变体返回基本类型，valueOf版本返回对象。我相信valueOf版本还将使用内部引用池为给定值返回SAME对象，而不仅仅是具有相同内部值的另一个实例。

好吧，Integer.valueOf(String)的API确实说过，String的解释就像给了Integer.parseInt(String)一样。然而，valueOf(String)返回一个String0 Integer()对象，而parseInt(String)返回一个原语int。

如果你想享受Integer.valueOf(int)潜在的缓存好处，你也可以使用这个讨厌的东西:

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

现在，如果你想要的是对象而不是原语，那么使用valueOf(String)可能比用parseInt(String)创建一个新对象更有吸引力，因为前者在Integer、Long、Double等中始终存在。

整数。parseInt可以只返回int作为本机类型。

整数。valueOf实际上可能需要分配一个Integer对象，除非该整数恰好是预分配的整数之一。这样成本更高。

如果你只需要本地类型，使用parseInt。如果你需要一个对象，使用valueOf。

此外，由于这种潜在的分配，自动装箱实际上在各方面都不是一件好事。它可以使事情变慢。

1. 对于ValueOf ->，它正在创建一个Integer对象。不是基元类型，也不是静态方法。
2. 在ParseInt的情况下。ParseFloat ->返回各自的基本类型。And是一个静态方法。

我们可以根据需要使用任何一种。对于ValueOf，因为它正在实例化一个对象。如果我们只需要一些文本的值，它会消耗更多的资源，那么我们应该使用parseInt,parseFloat等。

因为您可能正在使用jdk1.5+，它会自动转换为int。所以在你的代码中，它首先返回Integer，然后自动转换为int。

你的代码和

int abc = new Integer(123);

如果你检查Integer类，你会发现valueof调用parseInt方法。最大的区别是当你调用valueof API时缓存。如果值在-128到127之间，它会缓存。更多信息请参见下面的链接

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

查看Java源代码:valueOf使用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返回int(不是Integer)

/**
* 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);
}

整数valueOf(字符串s)

1. 参数被解释为表示一个带符号的十进制整数，就像参数被赋给parseInt(java.lang.String)方法一样。

2. 结果是一个Integer对象，表示字符串指定的整数值。

换句话说，该方法返回一个Integer对象，其值等于: 新的整数(Integer.parseInt (s)) < / p > < /李>

• 返回对象的值 -转换为包装器类
• 方法用于 -转换为基本类型

整数。parseInt只接受String并返回原始整数类型(int)。

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

Iteger.valueOf(200)将给出200的新整数。就像new Integer(200) Iteger.valueOf(127)与Integer = 127相同;

如果你不想将String转换为Integer，请使用Iteger.valueOf。

如果你不想将String转换为简单的int，请使用Integer.parseInt。它工作得更快。

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

比较Integer.valueOf(127) == Integer.valueOf(127)返回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

因为它从缓存中获取具有相同引用的Integer对象。

但是Integer. valueof (128) == Integer. valueof(128)为false，因为128超出了IntegerCache的范围，它返回新的Integer，因此对象将有不同的引用。