Java 如何判断Integer类型的值是否相等

public class Demo {

     public static void main(String[] args) {

         Integer c = - 128 ;

         Integer d = - 128 ;

         System.out.println( "c == d: " + (c == d));

         System.out.println( "c.equals(d): " + c.equals(d));

         System.out.println( "c.intValue() == d.intValue(): " + (c.intValue() == d.intValue()));

         System.out.println( "Objects.equals(c, d): " + Objects.equals(c, d));

         Integer e = 127 ;

         Integer f = 127 ;

         System.out.println( "e == f: " + (e == f));

         System.out.println( "e.equals(f): " + e.equals(f));

         System.out.println( "e.intValue() == f.intValue(): " + (e.intValue() == f.intValue()));

         System.out.println( "Objects.equals(e, f): " + Objects.equals(e, f));

         Integer g = 128 ;

         Integer h = 128 ;

         System.out.println( "g == h: " + (g == h));

         System.out.println( "g.equals(h): " + g.equals(h));

         System.out.println( "g.intValue() == h.intValue():" + (g.intValue() == h.intValue()));

         System.out.println( "Objects.equals(g, h): " + Objects.equals(g, h));

     }

}

/**

      * Cache to support the object identity semantics of autoboxing for values between

      * -128 and 127 (inclusive) as required by JLS.

      *

      * The cache is initialized on first usage.  The size of the cache

      * may be controlled by the -XX:AutoBoxCacheMax=<size> option.

      * During VM initialization, java.lang.Integer.IntegerCache.high property

      * may be set and saved in the private system properties in the

      * sun.misc.VM class.

      */

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

                 int i = parseInt(integerCacheHighPropValue);

                 i = Math.max(i, 127 );

                 // Maximum array size is Integer.MAX_VALUE

                 h = Math.min(i, Integer.MAX_VALUE - (-low));

             }

             high = h;

             cache = new Integer[(high - low) + 1 ];

             int j = low;

             for ( int k = 0 ; k < cache.length; k++)

                 cache[k] = new Integer(j++);

         }

         private IntegerCache() {}

     }

Integer newInt = new Integer( 10 );

//自动装箱操作，编译后class文件中为：Integer num = Integer.valueOf(10);

Integer num = 10 ;

//num.intValue()为解包操作

int intNum = num.intValue();

/**

  * 输出结果为true----false----true，原因：

  * 1、 Integer为引用类型,引用类型栈中变量表示一个地址指向堆中的一片内存空间

  * 2、 newInt.equals(num)为true是因为Integer重写了equals方法，equals方法中实际是值比较

  * 3、(newInt == num)为false因为两个变量不指向同一片内存

  * 4、(intNum==num)结果为true是因为intNum是基本数据类型，值直接存在栈中，两者比较的是值

  */

System.out.println(newInt.equals(num)+ "----" +(newInt == num)+ "----" +(intNum==num));

private final int value;

public boolean equals(Object obj) {

     if (obj instanceof Integer) {

      //将对象强制转换为Integer类型，然后自动拆箱进行==比较

         return value == ((Integer)obj).intValue();

     }

     return false ;

}

public Integer( int value) {

  //参数为int 直接赋值

  this .value = value;

}

public Integer(String s) throws NumberFormatException {

  //参数为String的情况下调用paseInt()方法进行赋值，10表示为按10进制转换

  this .value = parseInt(s, 10 );

}