494

有什么parseInt()不同valueOf()？

他们似乎对我做了完全相同的事情（也适用于parseFloat(),parseDouble()等parseLong()，它们与 有什么不同Long.valueOf(string)？

此外，按照惯例，哪一个更可取并且更经常使用？

4

11 回答 11

463

好吧，API forInteger.valueOf(String)确实说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等。

于 2009-02-03T20:04:33.503 回答
80

从这个论坛：

parseInt()返回原始整数类型 ( int )，从而valueOf返回 java.lang.Integer，它是表示整数的对象。在某些情况下，您可能需要一个 Integer 对象，而不是原始类型。

当然，另一个明显的区别是intValue是一个实例方法，而parseInt是一个静态方法。

于 2009-02-03T20:01:12.450 回答
42 
Integer.valueOf(s)

类似于

new Integer(Integer.parseInt(s))

不同之处在于valueOf()返回一个Integer，并parseInt()返回一个int（原始类型）。另请注意，它valueOf()可能会返回一个缓存的Integer实例，这可能会导致==测试结果间歇性正确的混乱结果。在自动装箱之前，便利性可能会有所不同，在 java 1.5 之后，这并不重要。

此外，Integer.parseInt(s)也可以采用原始数据类型。

于 2009-02-03T20:01:45.350 回答
20

查看 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);
}
于 2014-10-28T08:53:29.387 回答
6

Integer.parseInt 可以只返回 int 作为本机类型。

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

如果您只需要本机类型，请使用 parseInt。如果您需要一个对象，请使用 valueOf。

此外，由于这种潜在的分配，自动装箱实际上在各个方面都不是好事。它可以减慢速度。

于 2009-02-03T20:28:28.727 回答
3
  • 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，如果输入小于 -128 或大于 127，则返回 new Integer。如果输入在范围 (-128 - 127) 内，它总是从内部整数缓存。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，所以对象会有不同的引用。

于 2019-02-15T14:09:55.953 回答
1

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

于 2009-02-03T20:02:37.780 回答
0

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

您的代码与

int abc = new Integer(123);
于 2010-12-16T09:05:23.073 回答
0

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

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

于 2014-07-23T17:58:28.300 回答
0

公共静态整数 valueOf(String s)

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

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

  3. 换句话说，此方法返回一个等于以下值的 Integer 对象： new Integer(Integer.parseInt(s))

于 2015-09-29T03:31:14.670 回答
-2
  1. 在 ValueOf -> 的情况下，它正在创建一个 Integer 对象。不是原始类型，也不是静态方法。
  2. 在 ParseInt.ParseFloat -> 的情况下，它返回各自的原始类型。并且是一个静态方法。

我们应该根据需要使用任何一种。在 ValueOf 的情况下，它正在实例化一个对象。如果我们只需要一些文本的值，它将消耗更多资源，那么我们应该使用 parseInt、parseFloat 等。

于 2009-08-26T07:08:04.440 回答