java int 与 Integer比较

int与 Integer  之间  ==  比较

 

 

	
	public static void main(String[] args) {
		int basicInt11 = 1;
		Integer wrapperInteger11 = 1;
		Integer wrapperInteger12 = new Integer(1);
		Integer wrapperInteger13 = Integer.valueOf(1);
		
		System.out.println("1[int] == 1[Integer] -> " + (basicInt11 == wrapperInteger11));
		System.out.println("1[int] == 1[new Integer(1)] -> " + (basicInt11 == wrapperInteger12));
		System.out.println("1[int] == 1[Integer.valueOf(1)] -> " + (basicInt11 == wrapperInteger13));
		
		System.out.println("1[Integer] == 1[new Integer(1)] -> " + (wrapperInteger11 == wrapperInteger12));
		System.out.println("1[Integer] == 1[Integer.valueOf(1)] -> " + (wrapperInteger11 == wrapperInteger13));
		System.out.println("====================================");
		int basicInt21 = 128;
		Integer wrapperInteger21 = 128;
		Integer wrapperInteger22 = new Integer(128);
		Integer wrapperInteger23 = Integer.valueOf(128);
		System.out.println("128[int] == 128[Integer] -> " + (basicInt21 == wrapperInteger21));
		System.out.println("128[int] == 128[new Integer(1)] -> " + (basicInt21 == wrapperInteger22));
		System.out.println("128[int] == 128[Integer.valueOf(1)] -> " + (basicInt21 == wrapperInteger23));
		
		System.out.println("128[Integer] == 128[new Integer(1)] -> " + (wrapperInteger21 == wrapperInteger22));
		System.out.println("128[Integer] == 128[Integer.valueOf(1)] -> " + (wrapperInteger21 == wrapperInteger23));
	}

 

结果
1[int] == 1[Integer] -> true
1[int] == 1[new Integer(1)] -> true
1[int] == 1[Integer.valueOf(1)] -> true
1[Integer] == 1[new Integer(1)] -> false
1[Integer] == 1[Integer.valueOf(1)] -> true
====================================
128[int] == 128[Integer] -> true
128[int] == 128[new Integer(1)] -> true
128[int] == 128[Integer.valueOf(1)] -> true
128[Integer] == 128[new Integer(1)] -> false
128[Integer] == 128[Integer.valueOf(1)] -> false

 

 

 

从以上可看出，基本类型与包装类型  ==  比较始终相对。

而包装类型，值一样，采取初始化方式不一样，  ==结果不一样。

1[Integer] == 1[new Integer(1)] -> false
1[Integer] == 1[Integer.valueOf(1)] -> true

值为 128的时候， 128[Integer] == 128[Integer.valueOf(1)] -> false  结果也不一样。

 

分析，java 的数据分为基本类型和引用类型。  ==  进行比较。则基本类型比较的是值，  引用类型则比较的是引用地址。

同一个class的不同对象（new 出来的） 必然引用地址不想等。

查看 Integer 源码：

 

    public Integer(int value) {
        this.value = value;
    }

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

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

 

 

从源码可看出，  new Integer(1)  与  Integer.valueOf(1) 初始化是不一样的。

new Integer(1) 是完全新建一个对象。

Integer.valueOf(1) 则会先查找本地缓存是否存在该对象，存在则直接返回，不存在，则新建一个对象。

而 Intger aa = 1 , 这种格式，JVM是怎么初始化的呢？ 这其实需要把 .java文件，先转成 .class文件，然后再反编译.class文件看，即可明白。

设上面为  A.java 则windows下面， 在此文件目录  shift +右键  选择：在此处打开命令，  输入  javac A.java

则通过 Java Decompiler 打开  A.class

 

  public static void main(String[] paramArrayOfString)
  {
    int i = 1;
    Integer localInteger1 = Integer.valueOf(1);
    Integer localInteger2 = new Integer(1);
    Integer localInteger3 = Integer.valueOf(1);

    System.out.println(new StringBuilder().append("1[int] == 1[Integer] -> ").append(i == localInteger1.intValue()).toString());
    System.out.println(new StringBuilder().append("1[int] == 1[new Integer(1)] -> ").append(i == localInteger2.intValue()).toString());
    System.out.println(new StringBuilder().append("1[int] == 1[Integer.valueOf(1)] -> ").append(i == localInteger3.intValue()).toString());

    System.out.println(new StringBuilder().append("1[Integer] == 1[new Integer(1)] -> ").append(localInteger1 == localInteger2).toString());
    System.out.println(new StringBuilder().append("1[Integer] == 1[Integer.valueOf(1)] -> ").append(localInteger1 == localInteger3).toString());
    System.out.println("====================================");
    int j = 128;
    Integer localInteger4 = Integer.valueOf(128);
    Integer localInteger5 = new Integer(128);
    Integer localInteger6 = Integer.valueOf(128);
    System.out.println(new StringBuilder().append("128[int] == 128[Integer] -> ").append(j == localInteger4.intValue()).toString());
    System.out.println(new StringBuilder().append("128[int] == 128[new Integer(1)] -> ").append(j == localInteger5.intValue()).toString());
    System.out.println(new StringBuilder().append("128[int] == 128[Integer.valueOf(1)] -> ").append(j == localInteger6.intValue()).toString());

    System.out.println(new StringBuilder().append("128[Integer] == 128[new Integer(1)] -> ").append(localInteger4 == localInteger5).toString());
    System.out.println(new StringBuilder().append("128[Integer] == 128[Integer.valueOf(1)] -> ").append(localInteger4 == localInteger6).toString());
  }

 从上可看出  javac 后的二进制代码与写的有些不一样。 这是因为，编译器对此进行了优化（可能不同版本编译器，上面结果还有些不一样）。

Integer a = 1;  其实编译后，JVM看到的是 Integer a = Integer.valueOf(1);

 基本类型和包装类型比较时，  int b=1  ; Intger a=1;  == 两边，只要有基本类型， 则另外一边返回的也一定是基本类型 （localInteger5.intValue()）。

因此是基本类型的值比较。

 

    public int intValue() {
        return value;
    }

 

 

总结：  用 == 的时候 一定要保证是基本类型的比较，而不是引用类型的比较。当存在包装类型的时候， 最好转化为 基本类型，再用 ==，防止出现 ==两边都是包装类型。