Java语言之Integer类

Java之Integer类

Integer类简介：

Integer类是基本数据类型int的包装器类，是抽象类Number的子类，位于java.lang包中。
Integer类在对象中包装了一个基本类型int的值，也就是每个Integer对象包含一个int类型的字段。在Integer源码中如下定义：
private final int value;

字段:

• [static int] MAX_VALUE：值为 2³¹－1 的常量，它表示 int 类型能够表示的最大值。
• [static int] MIN_VALUE：值为 －2³¹ 的常量，它表示 int 类型能够表示的最小值。
• [static int] SIZE： 用来以二进制补码形式表示 int 值的比特位数。
• [static Class] TYPE：表示基本类型 int 的 Class 实例。
• [static int] BYTES：返回int值所占的字节数。

构造方法
Integer类提供了两种构造方法：它们都会返回一个Integer对象

（1）Integer(int value);

（2）Integer(String s); //要注意的是字符串不能包含非数字字符，否则会抛出NumberFormatException

（3）除此之外，还可以给Integer对象直接赋值，如：Integer a = 10;

一些重要的方法

返回值	方法名	方法的描述
[static int]	bitCount(int i)	返回指定 int 值的二进制补码表示形式的 1 位的数量
[static int]	compare(int x,int y)	比较x和y的值，当x大于y时返回1，当x等于y时返回0，否则返回-1
[int]	compareTo(Integer anotherInteger)	在数值上比较两个Integer对象
[boolean]	equals(Object obj)	比较此对象与指定对象
[int]	hashcode()	返回此对象的哈希码
[static int]	parseInt(String str)	将字符串参数作为有符号十进制数进行解析
[static String]	toBinaryString(int i)	以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式
[String]	toString()	返回该Integer值得String对象
[static Integer]	valueOf(int i)	返回一个表示指定的 int 值的 Integer 实例

特别注意：

（1）“==”和equals()方法：在Integer类中，“==”用来比较对象地址是否相同，并且Integer类重写了equals(Object obj)方法，在equals(Object obj)方法中，会先判断参数中的对象obj是否是Integer类型的对象，如果是则判断值是否相同，值相同则返回true，值不同则返回false,如果obj不是Integer类的对象，则返回false。
需要注意的是：当参数是基本类型int时，编译器会给int自动装箱成Integer类，然后再进行比较。

	public static void main(String[] args) {
		int t1 = 128;
		int t2 = 128;
		Integer t3 = 127;
		Integer t4 = 127;
		Integer t5 = 100;
		int t6=100;
		System.out.println(t5.equals(t6));	//true
		
		String s1 = "123";
		String s2 = "123";
		String s3 = new String("123");
		String s4 = new String("123");
		System.out.println(t1 == t2);		//true
		System.out.println(t3 == t4);		//false
		System.out.println(t3.equals(4));	//false
		System.out.println(s1 == s2);		//true
		System.out.println(s1.equals(s2));	//true
		System.out.println(s3 == s4);		//false
		System.out.println(s3.equals(s4));	//true
	}

//Integer类中的equals(Object obj)源代码

 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

//int和Integer对象用构造方法、直接赋值方法赋值比较
int a = 200;
Integer b = new Integer(200);
Integer c = 200;
        
//b和c都是Integer对象，所以用“==”比较时，就是比较内存地址值是否相等
System.out.println(b == c);  //false
System.out.println(b.equals(c));  //true
        
//a在进行比较时，会自动装箱
System.out.println(b.equals(a));  //true
        
//因为b是Integer对象，a是基本数据类型int的变量，当进行“==”比较时，b会自动拆箱成int，从而比较的就是变量的值是否相等

System.out.println(b == a);   //true

（2）Integer直接赋值和valueOf()方法，下面来看下面两段代码的不同：

Integer i02 = 59;
Integer i03 = Integer.valueOf(59);
Integer i04 = new Integer(59);
    
System.out.println(i02 == i03);  //true
System.out.println(i02 == i04);  //false
System.out.println(i03 == i04);  //false

Integer i02 = 200;
Integer i03 = Integer.valueOf(200);
Integer i04 = new Integer(200);
        
System.out.println(i02 == i03);  //false
System.out.println(i02 == i04);  //false
System.out.println(i03 == i04);  //false

我们可以看到上面两段代码只是赋给对象的值不同，但是在判断”i02 == i03“时得到的结果却不同，这是为何：当使用直接赋值如”Integer i01 = 59“的时候，会调用Integer的valueOf()方法，这个方法就是返回一个Integer对象，但是在返回前，作了一个判断，判断要赋给对象的值i是否在[-128,127]区间中，且IntegerCache（是Integer类的内部类，里面有一个Integer对象数组，用于存放已经存在的且范围在[-128,127]中的对象）中是否存在此对象，如果存在，则直接返回引用，否则，创建一个新对象返回。那么我们就可以知道，200这个数字不在[-128，127]中，所以会直接创建一个新对象返回，i02和i03就是两个不同的对象。而59属于[-128，127]中，当创建i03时，会直接返回引用，此时i02和i03都指向同一个地址。

以第一段代码为例：”Integer i02 = 59"：因为程序初次运行，没有59，所以直接创建一个对象返回；“Integer i03 = Integer.valueOf(59)”：因为IntegerCache中已经存在59，所以直接返回引用；“Integer i04 = new Integer(59)”：直接创建一个新对象。

JVM中一个字节一下的整型数据（即[128,127]）会在JVM启动时加载进内存，除非用new Integer()显示的创建对象，否则都是同一对象。

//Integer类中的valueOf()源代码 

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

参考文献

https://www.cnblogs.com/zwxblog/p/7788573.html