java中parseInt()和valueOf()的区别？
Posted
技术标签:
【中文标题】java中parseInt()和valueOf()的区别？【英文标题】：Different between parseInt() and valueOf() in java? 【发布时间】：2010-10-05 06:03:19 【问题描述】：parseInt() 与 valueOf() 有何不同？
他们似乎对我做同样的事情（也适用于parseFloat()、parseDouble()、parseLong() 等，它们与Long.valueOf(string) 有何不同？
另外，按照惯例，哪一个更可取并且更常用？
【问题讨论】：
【参考方案1】：好吧，Integer.valueOf(String) 的 API 确实表明 String 的解释与将其提供给 Integer.parseInt(String) 完全相同。然而，valueOf(String) 返回一个new Integer() 对象，而parseInt(String) 返回一个原始int。
如果你想享受 Integer.valueOf(int) 的潜在缓存优势，你也可以使用这个碍眼的东西：
Integer k = Integer.valueOf(Integer.parseInt("123"))
现在，如果您想要的是对象而不是原始对象，那么使用valueOf(String) 可能比使用parseInt(String) 制作新对象更有吸引力，因为前者始终存在于Integer、Long 、Double等
【讨论】：
这两种方法在性能或内存方面是否存在差异？Integer.valueOf(Integer.parseInt("123")) 与 Integer.valueOf("123") 或 Integer.valueOf(123) 相比没有任何好处，除了浪费周期和程序的大小。
有一个区别——由 valueOf 分配的新对象（可能）带有开销（对象的内存、处理、GC），而普通的 int 非常“轻量级”。 （对于最常见的值，您将获得对预先存在的对象的引用，这会有所帮助。）
Integer.valueOf(String) 执行与Integer.valueOf(int) 完全相同的缓存。其实就是实现为Integer.valueOf(Integer.parseInt(…))...
@Khez 它不可能返回原始int。签名说它返回一个Integer，这正是它的作用。当它说它返回“新”Integer 时，这个答案也部分不正确。这不是它在 Javadoc 中所说的。可以免费返回缓存的Integer。【参考方案2】：
来自this forum：
parseInt()返回原始整数 类型 (int)，其中valueOf返回 java.lang.Integer，即对象 代表整数。那里 是你可能想要的情况 一个整数对象，而不是 原始类型。当然，还有一个明显的区别 是 intValue 是实例方法吗 其中 parseInt 是一个静态方法。
【讨论】：
值得一提：valueOf 版本还将使用内部引用池为给定值返回 SAME 对象，而不仅仅是具有相同内部值的另一个实例。这意味着给定以这种方式返回的两个 Long，a.equals(b) == true 并且 a == b 为 true 正如进一步证明的那样，您对字符串版本是正确的，我在考虑原始版本。 Long.valueOf(5) 将始终返回相同的对象。字符串版本返回新对象，原始版本返回相同的对象 @bassezero。此外，该池有限制。我认为是 -127 到 127。 参考池的大小是一个实现细节的真实例子；它甚至可以在补丁版本中增加大小，你不应该依赖任何事情。 @OscarRyz 实际上是 -128 到 127。请注意，JVM 提供了一个参数来为缓存设置更高的上限。但是，您不能重新定义最低界限：***.com/questions/29633158/…【参考方案3】：Integer.valueOf(s)
类似于
new Integer(Integer.parseInt(s))
区别在于valueOf() 返回一个Integer，而parseInt() 返回一个int（原始类型）。另请注意，valueOf() 可以返回缓存的Integer 实例，这可能会导致混淆结果，== 测试的结果似乎间歇性正确。在autoboxing 之前，在便利性上可能会有所不同，在 java 1.5 之后，这并不重要。
此外，Integer.parseInt(s) 也可以采用原始数据类型。
【讨论】：
valueOf() 可以为具有相同参数的连续调用返回相同的对象（并且对于介于 -128 和 127 之间的参数是必需的）。 new Integer() 将始终创建一个新对象。 哪个用得比较多？我最应该使用哪一个？ 如果需要int，使用parseInt()，如果需要Integer，使用valueOf() @Joan d Silva 从你的最后一行开始，我认为 Integer.parseInt(s) 只能作为字符串，而 Integer.ValueOf(s) 可以将 int 和字符串作为输入参数跨度> 【参考方案4】：查看 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);
【讨论】：
【参考方案5】：Integer.parseInt 可以只返回 int 作为原生类型。
Integer.valueOf 实际上可能需要分配一个 Integer 对象，除非该整数恰好是预分配的整数之一。这成本更高。
如果您只需要原生类型，请使用 parseInt。如果您需要一个对象，请使用 valueOf。
此外，由于这种潜在的分配，自动装箱实际上并不是在各个方面都是好事。它可以减慢速度。
【讨论】：
【参考方案6】： valueOf - 转换为 Wrapper 类 parseInt - 转换为原始类型Integer.parseInt 只接受 String 并返回原始整数类型 (int)。
public static int parseInt(String s) throws NumberFormatException
return parseInt(s,10);
Iteger.valueOf 接受 int 和 String。 如果 value 是 String，valueOf 使用 parseInt 将其转换为简单的 int，如果 input 小于 -128 或大于 127，则返回 new Integer。 如果输入在范围 (-128 - 127) 内，它总是从内部 IntegerCache 返回 Integer 对象。 Integer 类维护一个内部静态 IntegerCache 类，它充当缓存并保存从 -128 到 127 的整数对象，这就是为什么当我们尝试获取 127 的整数对象（例如）时，我们总是得到相同的对象。
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) 是假的，因为 128 超出了 IntegerCache 的范围，它返回新的 Integer，所以对象会有不同的引用。
【讨论】：
请不要滥用粗体格式：它会降低帖子的可读性。【参考方案7】：parse* 变体返回原始类型，valueOf 版本返回对象。我相信 valueOf 版本也将使用内部引用池来为给定值返回 SAME 对象，而不仅仅是具有相同内部值的另一个实例。
【讨论】：
实际上，并不完全正确。一开始我自己也是这么想的，但是 Integer.valueOf(String) 的 Javadocs 明确指出它等同于 new Integer(Integer.parseInt(String))。不过，Integer.valueOf(int) 确实会缓存。 您对字符串版本是正确的，我在考虑原始版本。 Long.valueOf(5) 将始终返回相同的对象。【参考方案8】：如果你检查 Integer 类，你会发现 valueof 调用了 parseInt 方法。最大的区别是调用 valueof API 时的缓存。如果值在 -128 到 127 之间，它会缓存请在下面的链接中找到更多信息
http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html
【讨论】：
【参考方案9】：因为您可能正在使用 jdk1.5+ 并且它会自动转换为 int。因此，在您的代码中，它首先返回 Integer，然后自动转换为 int。
您的代码与
相同int abc = new Integer(123);
【讨论】：
【参考方案10】：public static Integer valueOf(String s)
-
该参数被解释为表示一个带符号的十进制整数，就像将该参数提供给 parseInt(java.lang.String) 方法一样。
结果是一个 Integer 对象，表示字符串指定的整数值。
换句话说，此方法返回一个整数对象，其值等于： 新整数(Integer.parseInt(s))
【讨论】：
【参考方案11】：-
在 ValueOf -> 的情况下，它正在创建一个 Integer 对象。不是原始类型，也不是静态方法。
如果是 ParseInt.ParseFloat -> 它返回各自的原始类型。并且是一个静态方法。
我们应该根据需要使用任何一种。在 ValueOf 的情况下，它正在实例化一个对象。如果我们只需要一些文本的值，它会消耗更多的资源，那么我们应该使用 parseInt，parseFloat 等。
【讨论】：
以上是关于java中parseInt()和valueOf()的区别？的主要内容，如果未能解决你的问题，请参考以下文章
Java中Integer.parseInt和Integer.valueOf，你还傻傻分不清吗？
C++ - 替代 Integer.parseInt() 和 String.valueOf() [重复]
java中 Integer的decode()，parseInt()，valueOf()有啥区别？
Java中 intValue，parseInt，Valueof