Java——包装类，Integer

包装类

含义：8种基本数据类型对应的类

基本数据类型	包装类	继承关系
byte	Byte	Object.Number.Byte
short	Short	Object.Number.Short
int	Integer	Object.Number.Integer
long	Long	Object.Number.Long
float	Float	Object.Number.Float
double	Double	Object.Number.Double
char	Character	Object.Character
boolean	Boolean	Objecr.Boolean

包装类的出现原因：
Java为纯面向对象语言（一切皆对象），8种基本数据类型不能创建对象，就破坏了Java为纯面向对象语言的特征，所以Java又为8种基本数据类型匹配了对应的类，这种类叫做包装类、封装类

注意：int对应Integer，char对应Character，其余的包装类都是基本数据类型首字母大写

包装类的出现原因：
Java为纯面向对象语言（一切皆对象），8种基本数据类型不能创建对象，就破坏了Java为纯面向对象语言的特征，所以Java又为8种基本数据类型匹配了对应的类，这种类叫做包装类、封装类

包装类中的常用方法

手动装箱：基本数据类型 -> 包装类

int i =100;
Integer integer = Integer.valueOf(i);
System.out.println(integer);//100

手动拆箱：包装类 -> 基本数据类型

Integer integer = new Integer(100);
int i = integer.intValue();
System.out.println(i);//100

JDK1.5开始提供了自动装箱、自动拆箱

自动装箱：基本数据类型 -> 包装类

int i =100;
Integer integer = i;//底层实现：Integer.valueOf(i);
System.out.println(integer);//100				

自动拆箱：包装类 -> 基本数据类型

Integer integer = new Integer(100);
int i = integer;//底层实现：integer.intValue();
System.out.println(i);//100

Integer底层源码

测试：

public class Test02 {
	
	public static void main(String[] args) {
		
		Integer integer1 = Integer.valueOf(100);
		Integer integer2 = Integer.valueOf(100);
		System.out.println(integer1 == integer2);//true
		
		Integer integer3 = Integer.valueOf(200);
		Integer integer4 = Integer.valueOf(200);
		System.out.println(integer3 == integer4);//false
		
		System.out.println("---------------------");
		
		MyInteger myInteger1 = MyInteger.valueOf(100);
		MyInteger myInteger2 = MyInteger.valueOf(100);
		System.out.println(myInteger1 == myInteger2);//true
		
		MyInteger myInteger3 = MyInteger.valueOf(200);
		MyInteger myInteger4 = MyInteger.valueOf(200);
		System.out.println(myInteger3 == myInteger4);//false
		
	}
}

底层实现Integer：

public class MyInteger {

	private int value;

	public MyInteger(int value) {
		this.value = value;
	}
	public int intValue(){
		return value;
	}
	
	public static MyInteger valueOf(int i){
		if(i >= MyIntegerCache.low && i <= MyIntegerCache.high){
			return MyIntegerCache.cache[i - MyIntegerCache.low];
		}
		return new MyInteger(i);
	}
	
	private static class MyIntegerCache{
		
		public static final int low = -128;
		public static final int high = 127;
		public static final MyInteger[] cache;
		
		static{
			cache = new MyInteger[high - low + 1];
			
			int j = low;
			for (int i = 0; i < cache.length; i++) {
				cache[i] = new MyInteger(j);
				j++;
			}
		}
	}
	@Override
	public String toString() {
		return String.valueOf(value);//将int值转换为字符串
	}
}