Integer.parseInt(s)与Integer.valueOf(s)区别

一、Integer.parseInt(s)用法

    String s1 = "1000";
    String s2 = "1000";
    int n1 = Integer.parseInt(s1);
    int n2 = Integer.parseInt(s2);
    if (n1 == n2) {         
        System.out.println("Integer.parseInt(s1) == Integer.parseInt(s2)");
    }

输出：

Integer.parseInt(s1) == Integer.parseInt(s2)

Integer.parseInt(s)的作用就是把字符串s解析成有符号的int基本类型。

二、Integer.valueOf(s)用法

    String s = "123";
    Integer integer = Integer.valueOf(s);
    System.out.println("integer : " + integer);

Integer.valueOf(s)把字符串s解析成Integer对象类型，返回的integer 可以调用对象中的方法。

三、Integer.parseInt(s)与Integer.valueOf(s)的区别

Integer.parseInt(s)多次解析同一个字符串得到的int基本类型数据是相等的，可以直接通过“==”进行判断是否相等。

int是基本类型，不含有equals方法，所以只能用“==”比较。

Integer.valueOf(s)多次解析相同的一个字符串时，得到的是Integer类型的对象，得到的对象有时是同一个对象，有时是不同的对象，要根据把s字符串解析的整数值的大小进行决定：如果s字符串对应的整数值在 -128_{127之间，则解析出的Integer类型的对象是同一个对象；如果s字符串对应的整数值不在-128}127之间，则解析出的Integer类型的对象不是同一个对象。不管对象是否相等，对象中的value值是相等的。

    String s = "100";
    Integer i1 = Integer.valueOf(s);
    Integer i2 = Integer.valueOf(s);
    if (i1 == i2) { //两个对象相等
        System.out.println("i1 == i2");
    }
    if (i1.equals(i2)) { //两个对象中的value值相等
        System.out.println("i1.equals(i2)");
    }

输出：

i1 == i2
i1.equals(i2)

通过上面示例，字符串s对应的整数值为100，在-128~127之间，所以解析出的两个对象i1和i2是相等的。equals是比较的两个对象i1和i2中的value值是否相等，“==”是比较i1和i2两个对象是否相等。

当s字符串对应的整数值不在-128~127之间，示例如下：

    String s = "1000";
    Integer i1 = Integer.valueOf(s);
    Integer i2 = Integer.valueOf(s);
    if (i1 != i2) { //两个对象不相等
        System.out.println("i1 != i2");
    }
    if (i1.equals(i2)) { //两个对象中的value值相等
        System.out.println("i1.equals(i2)");
    }

输出：

i1 != i2
i1.equals(i2)

可见，当s字符串对应的整数值为1000，不在-128~127之间，通过Integer.valueOf(s)解析出的两个对象i1和i2是不同的对象，对象中的value值是相同的。

原因： 为什么Integer.valueOf(s)会出现这种情况呢？这是由于JDK中源码已经定义好的。由于在-128—127之间的整数值用的比较频繁，当每次要创建一个value值在-128—127之间的Integer对象时，直接从缓存中拿到这个对象，所以value值相同的Integer对象都是对应缓存中同一个对象。-128~127之外的整数值用的不是太频繁，每次创建value值相同的Integer对象时，都是重新创建一个对象，所以创建的对象不是同一个对象。这个从JDK中源码可以看出

public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, 10));
}

然后上面的源码又调用了Integer.valueOf(int)方法

public static Integer valueOf(int i) {
    /*IntegerCache.low为 -128；
    IntegerCache.high默认为127，但可以在JVM进行配置，一般默认就是127*/
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        /*如果i在-128~127之间，从缓存中取对象*/
        return IntegerCache.cache[i + (-IntegerCache.low)];
    /*如果i不在-128~127之间，重新创建一个对象*/
    return new Integer(i);
}

四、Integer.parseInt(s)与Integer.valueOf(s)的联系

Integer.parseInt(s)是把字符串解析成int基本类型，Integer.valueOf(s)是把字符串解析成Integer对象类型，其实int就是Integer解包装，Integer就是int的包装，在jdk5中已经自动实现了自动解包装和自动包装，所以两种方式都能得到想要的整数值。

new Integer()与Integer.valueOf()

new Interger()

//Interger引用类型变量a中储存在堆中开辟的空间的地址，地址中储存100
Integer a=new Integer(100);

Interger.valueOf

 //直接调用Interger的属性valueOf,将int类型的10，隐式加包为Interger类型的10
 //再将转化后的10储存在Interger引用类型变量a中
Integer a=Integer.valueOf(10);

Integer a=new Integer(100); 
Integer b=new Integer(100); 
Integer c=Integer.valueOf(100); 
Integer d=Integer.valueOf(100); 
System.out.println(a==b); //false 
System.out.println(c==d); //ture

a,b只是储存了一个地址，100在堆中的储存地址，因此a,b进行比较输出结果肯定为false。 c,d中储存的是通过Interger.valueOf隐式加包后的100，c,d中储存的类型相同值也相同两者进行比较输出结果肯定为ture。

Interger类型中的valueOf类的源代码

 public static Integer valueOf(int i) {
     if (i >= IntegerCache.low && i <= IntegerCache.high)  //low=-128
     return IntegerCache.cache[i + (-IntegerCache.low)];
     return new Integer(i);
 }

该代码表示valueOf的隐式加包是有范围的只能加包**-128~127**，超过这个范围将用new Interger的方法。

所以如果是-128~127 用valueOf效率会高点，有缓存。

因此将代码中的100改为1000，两个输出将都是false，而且所用的方法也一样都是在堆中调用一个地址用来储存值，Interger类型的变量，储存地址。