【Java】6.1 Java 8增强的包装类

Java的基本类型包装

         所有的类都是Object的子类，除了8个基本类型，因为8个基本类型不能当做对象使用。但是Java为这8个基本类型提供了相应的包装类：其本质仍然是8个基本类型但是已经被包装过了，所以可以当做对象使用。

表6-1 基本类型数据和包装类之间的对应关系

基本数据类型	包装类
int	Integer
char	Character
float	Float
long	Long
double	Double
boolean	Boolean
byte	Byte
short	Short

【当有需要时】

1. 程序会自动把基本数据类型的值装成对应的包装类的实例，这就是自动装箱
2. 程序会自动把包装类的实例拆成对应的基本数据类型的值，这就是自动拆箱
3. 一句话：用包装类实例更方便
4. 进行自动装箱和自动拆箱时，要注意类型匹配，Integer类型只能拆箱成int基本类型，不要试图把Integer类型拆箱成boolean

public class AutoBoxingUnboxing {
	public static void main(String[] args) {
		//把一个基本类型变量赋值给Integer对象
		Integer inObj=5;
		//直接把一个boolean类型赋值给一个Object类型的变量
		Object boolObj=true;
		//直接把一个Integer对象赋值给int类型的变量
		int it=inObj;
		if(boolObj instanceof Boolean) {
			
			
			//先把Object对象强制换为Boolean类型，在赋给boolean变量
			boolean b=(Boolean)boolObj;
			
			System.out.println(b);
		}
	}
}

【代码分析】inObj 和 boolObj 是用到了装箱，it 用到了拆箱；instanceof 在前面学习过，是前后者是有具有继承关系的判断。

最后输出一个单词：true 

==================================================================================

基本类型变量之间的转换

把字符串类型转换成基本类型的两种方式

1. 利用包装类提供的parseXxx(String s)的静态方法（除了Character之外所有的包装类都提供利润该方法）
2. 利用包装类提供的Xxx(String s)构造器 —— Xxx都是一种基本类型或者基本类型的包装类

public class Primitive2String {
	public static void main(String[] args) {
		//// 把一个String类型装换为int变量
		String intstr = "123";
		int it1 = Integer.parseInt(intstr);
		int it2 = new Integer(intstr);
		System.out.println(it2);
		// 把一个String类型装换为float变量
		String floatstr = "2.36";
		float it3 = Float.parseFloat(floatstr);
		float it4 = new Float(floatstr);
		System.out.println(it4);

		// 把一个float类型装换为String变量
		String ftStr = String.valueOf(2.365f);
		System.out.println(ftStr);

		// 把一个double类型装换为String变量
		String dbStr = String.valueOf(5.56);
		System.out.println(dbStr);

		// 把一个boolean类型装换为String变量
		String boolStr = String.valueOf(false);
		System.out.println(boolStr.toUpperCase()); // toUpperCase()把小写给为大写
		System.out.println(boolStr);

	}
}

运行结果：

 基本数据类型和String对象之间的转换关系：

=========================================================================

Integer的数据缓存

public class Primitive2String {
	public static void main(String[] args) {

		Integer ina = 2;
		Integer inb = 2;
		System.out.println(ina == inb);// 输出true

		Integer biga = 128;
		Integer bigb = 128;
		System.out.println(biga == bigb);// 输出false
	}
}

出现这两个现象原因要从java.lang.Integer源代码查看分析：

//定义一个长度为256的Integer数组
static final Integer[] cache = new Integer[-(-128)+127+1];
static{
    //执行初始化-128~127的Integer实例，并放入cache数组中
    for(int i = 0; i < cache.length; i++){
        cache[i] = new Integer(i - 128);
    }
}

从上述源代码可以看出，程序把-128~127之间的整数自动装箱成Integer实例，放入一个名为cache的数组中缓存起来。若以后把一个-128~127之间的整数自动封装为一个Integer实例时，实际上是指机制相对应的数组元素，因此-128~127之间的同一个整数自动装箱时，永远都是引用cache数组的同一个数组元素，所以他们之间是相等的；但每次把不是-128~127之间的整数自动装箱成Integer实例时，系统总会重新创建一个Integer实例，所以会出现上述运行情况。