首先来看class类的注释介绍:
/**
* Integer类对基础类型int类进行了包装。
* Integer对象包含了一个类型为int的单一字段(字段名为value)。
* 此外,该类还提供了几种转换方法。
* int 转 String,String 转 int,
* 以及其他处理int的一些常数和方法。
* @since JDK1.0
*/
一:类定义
public final class Integer extends Number implements Comparable<java.lang.Integer>
从类定义中我们可以知道以下几点:
1、final修饰类,所以Integer类不能被继承
2、Integer继承了Number类,所以该类可以调用longValue、floatValue、doubleValue等系列方法返回对应的类型的值。
public abstract class Number implements java.io.Serializable {
private static final long serialVersionUID = -8742448824652078965L;
public abstract int intValue();
public abstract long longValue();
public abstract float floatValue();
public abstract double doubleValue();
public byte byteValue() {
return (byte)intValue();
}
public short shortValue() {
return (short)intValue();
}
}
3、Integer类实现了Comparable接口(这个接口只有compareTo一个方法),所以可以用compareTo进行比较,并且Integer对象只能和Integer类型的对象进行比较,不能和其他类型比较(至少调用compareTo方法无法比较)。
public interface Comparable<T> {
public int compareTo(T o);
}
二:属性
@Native private static final long serialVersionUID = 1360826667806852920L;
/**
* 计算机中32位int类型变量的范围,其中int类型是带符号整数,最高位为符号位。
* int 最小值 -2的31次方
*/
@Native
public static final int MIN_VALUE = 0x80000000;
/**
* int 最大值 2的31次方减1
*/
@Native
public static final int MAX_VALUE = 0x7fffffff;
/**
* 用来以二进制补码形式表示 int 值的比特位数。
*/
@Native public static final int SIZE = 32;
/**
* 用来以二进制补码形式表示 int 值的字节数。1.8以后才有
*/
public static final int BYTES = SIZE / Byte.SIZE;
/**
* 这是一个私有属性,
* value属性就是Integer对象中真正保存int值的。
*/
private final int value;
需要注意的就是这个int型的value属性。value属性就是Integer对象中真正保存int值的。
三:构造方法
在Integer类中提供了两个构造函数,分别针对构造参数为基本类型int和引用类型String。
这两个方法都是给当前的实例的value属性赋值,参数为int类型的构造器直接将参数赋值给value属性,
参数为String是将parseInt(String s, int radix)方法的返回值赋值。
/**
* 构造函数一
* 当我们使用new Integer(10)创建一个Integer对象的时候,就会用以下形式给value赋值。
*/
public Integer(int value) {
this.value = value;
}
/**
* 构造函数二
* 当我们使用Integer a = new Integer("2")创建一个Integer对象的时候;
* 它表示 String 参数所指示的 int 值。
*/
public Integer(String s) throws NumberFormatException {
//从构造方法中我们可以知道,初始化一个Integer对象的时候只能创建一个十进制的整数。
this.value = parseInt(s, 10);
}
四:面试题
public class Test {
public static void main(String[] args) {
Integer a = 100;
Integer b = 100;
Integer c = 200;
Integer d = 200;
System.out.println(a == b);//①
System.out.println(c == d);//②
}
}
代码①和②分别打印的结果是什么?
①TRUE ②FALSE
分析:JDK1.5之后,java提供了自动装箱和自动拆箱的功能。自动装箱也就是调用了Integer类的一个静态方法valueOf
方法。自动装箱也就是调用了Integer类的一个静态方法valueOf
方法,先看源码:
public static java.lang.Integer valueOf(int i) {
if (i >= java.lang.Integer.IntegerCache.low && i <= java.lang.Integer.IntegerCache.high)
return java.lang.Integer.IntegerCache.cache[i + (-java.lang.Integer.IntegerCache.low)];
return new java.lang.Integer(i);
}
public static class IntegerCache {
static final int low = -128;
static final int high;
static final java.lang.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);
h = Math.min(i, java.lang.Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new java.lang.Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new java.lang.Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert java.lang.Integer.IntegerCache.high >= 127;
}
private IntegerCache() {}
}
源码中有一个IntegerCache
,这一个私有的内部类。这个类缓存了-128到127
之间数字的包装类。意思就是当你new 一个int型的整数,先去判断是否在【-128到127】这个区间内,如果再就把缓存中的那个包装类返回,Integer a = 100和Integer b= 100,都在这个区间,所以它们返回的都是同一个缓冲对象,所以①处相等为TRUE。当不在【-128到127】这个区间内,就会去真正new一个新的,
Integer c = 200和Integer d = 200不在这个区间内,所以分别new了一个新的对象,所以②处不相等为FALSE。