Question

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

编辑：此外，哪些更可取，更常用于惯例？

Answer 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)制作一个新对象更有吸引力，因为前者始终存在于{{1} }}，Integer，Long等

Answer 2

来自this forum：

parseInt() 会返回原始整数   键入（ int ），其中 valueOf 返回    java.lang.Integer ，这是对象   代表整数。那里   是你可能想要的情况   一个Integer对象，而不是   原始类型。

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

Answer 3

Integer.valueOf(s)

类似于

new Integer(Integer.parseInt(s))

区别在于valueOf()返回Integer，parseInt()返回int（基本类型）。另请注意，valueOf()可以返回缓存的Integer实例，这可能会导致令人困惑的结果，==测试的结果似乎是间歇性正确的。在autoboxing之前，方便性可能会有所不同，在java 1.5之后它并不重要。

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

Answer 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

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

Answer 5

Integer.parseInt只能将int作为本机类型返回。

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

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

另外，由于这种潜在的分配，自动装箱在各方面都不是好事。它可以减慢事情。

Answer 6

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

您的代码与

相同

int abc = new Integer(123);

Answer 7

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

Answer 8

由于valueOf返回一个新的Integer对象，为什么下面的代码是正确的？

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

Answer 9

如果检查Integer类，您将找到callof parseInt方法的值。当你调用valueof API时，最大的不同就是缓存。如果值在-128到127之间，它会缓存。请在链接下方找到更多信息

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

Answer 10

public static Integer valueOf（String s）

该参数被解释为表示带符号的十进制整数，就像该参数被赋予parseInt（java.lang.String）方法一样。
结果是一个Integer对象，表示字符串指定的整数值。
换句话说，此方法返回一个等于值的Integer对象： new Integer（Integer.parseInt（s））

Answer 11

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）范围内，则始终从内部IntegerCache返回Integer对象。 Integer类维护一个内部静态IntegerCache类，该类充当缓存并保存从-128到127的整数对象，因此，当我们尝试获取127的整数对象（例如）时，总是得到相同的对象。

如果您不想从int 200获取新的Integer，请使用Iteger.valueOf（200）。 Iteger.valueOf（127）没有任何意义，因为它与Integer = 127;

相同。

如果您不想将String转换为新的Integer或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，因此对象将具有不同的引用。

Answer 12

在ValueOf的情况下 - ＆gt;它正在创建一个Integer对象。不是原始类型而不是静态方法。
如果是ParseInt.ParseFloat - ＆gt;它返回各自的原始类型。并且是一种静态方法。

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

java中的parseInt和valueOf之间的区别？

12 个答案: