Java中的包装类与基本数据类型详解（进阶一）

一、什么是java包装类

1）java包装类的基本概念

①首先包装类是类，是引用类型
②是为了方便拓展使用基本数据类型而进行封装的类

2）java基本数据类型对应的包装类型

四类：
整型（byte、short、int、long、）
浮点型 （float、double、）
boolean型（boolean）
char型（char）
注：一字节占八个bit位
1、整型（整数类型）

整型	占用空间	取值范围	对应的包装类
①byte	1个字节	-128~127	Byte
②short	2个字节	-32768~32767	Short
③int	4个字节	-2147483648~2147483647	Integer
④long	8个字节	-9223372036854774808~9223372036854774807	Long

注：对long型进行赋值时在结尾添加“L”或者“l”，否则系统自动将其定义为int型变量。

2、浮点型 （小数类型）

浮点型	占用空间	取值范围	对应的包装类
①double	8个字节	1.797693e+308~ 4.9000000e-324	Double
②float	4个字节	3.402823e+38 ~ 1.401298e-45	Float

3、boolean型（布尔型）

布尔型	占用空间	取值	对应的包装类
①boolean	1个字节	true/false	Boolean

4、char型（文本型）

布尔型	占用空间	取值	对应的包装类
①char	2个字节	单个汉字或字母	Character

3）java包装类和基本数据类型的区别

区别	基本数据类型	包装类
①是否对象	不是对象	是对象，拥有方法和字段
② 传递方式	值传递	引用地址的传递
③声明方式	不需要new关键字	需要new
④存储位置	值保存在值栈中	在堆中，然后通过对象的引用来调用
⑤初始值	int的初始值为 0 、 boolean的初始值为false	null
⑥使用方式	直接赋值使用	在集合如 coolection等使用

4）基本数据类型和包装类的声明初始化

①基本数据类型声明定义

byte a1 = 30;  
short s1 = 30000;     
int i1 = 200000;   
long one1 = 74000000000L;   // 后面加上一个 L / l 最好加 L，方便看

// 浮点型默认是 double。
// float 加 F/f 进行声明
float f1 = 3.14F; // 正常
double d1 = 3.14;

//单个字符
char a = 'w';
char b = '币';
char c = '\u0061';  // 表示字符 a

// 说出程序执行结果

boolean bbbb= false;
boolean dddd= true;

②包装类声明定义

//举几个例子得了，久不多写了，毕竟看这个的也不是太新手了
	Integer iObj = new Integer(123);
	Double dObj = Double.valueOf(3.14);//返回表示指定的 double值的 Double 实例。 

ps:看到个有趣的题目记录一下

boolean m = false;

if (m=true){
    System.out.println("a");
}else{
    System.out.println("b");
}
// 打印结果为a，对 m重新赋值了。

二、java包装类的一些细节

1）java包装类的使用场景

①要装入集合容器如 ArrayList等的时候需要作为对象来装入，必须使用包装类。
②方法中参数是Object类型，你要传入的是整形的话就只能转成Integer来使用了。

2）基本数据类型和包装类的转换：自动装箱和自动拆箱

什么是自动装箱与拆箱？
java编译器在jdk1.5 后的特性，自动装箱就是基本数据类型和对应的对象包装类型之间做一个转化，比如int转为Integer,.反之为自动拆箱。

//自动装箱
Integer i = new Integer(66);
Integer iObj = Integer.valueOf(123);	之前要这样，无法自动装箱
Integer iObj2 = 123;//后来可以通过这种方式自动装箱

//自动拆箱
int index2 = iObj.intValue();//之前要这样把Integer 类型手动拆箱转为int
int index1 = i;//后来可以通过这种方式自动拆箱

3）两个integer之间的==比较

①对于-128到127之间的数，会进行缓存。对于超过-128到127之间的数，不会进行缓存这时候比较地址
②两个封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true。

Integer i1 = 100;
Integer i2 = 100;
System.out.println(i1 == i2);	//true对于-128到127之间的数，会进行缓存，再创建i2时，
//java发现缓存中存在127这个数了，就直接取出来赋值给i2，所以i1 == i2的
System.out.println(i1.equals(i2));	//true两个封装型进行equals()比较，
首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true。

Integer i3 = 200;
Integer i4 = 200;
System.out.println(i3 == i4);  //false 对于超过-128到127之间的数，
不会进行缓存这时候比较地址，答案false

③new的方式会新建对象，地址信息不同

//--------------------------分割--------------------------------
Integer i9 = new Integer(50);
Integer i10 = new Integer(50);
System.out.println(i9 == i10);		//false  new的方式会新建对象，地址信息不同 

Integer i11 = -88;
Integer i12 = new Integer(-88);
System.out.println(i11 == i12);		//false 新建对象，地址信息不同 

④基本型和封装型进行“==”运算符的比较，封装型将会自动拆箱变为基本型后再进行比较，因此Integer会自动拆箱为int类型再进行比较，

//--------------------------分割--------------------------------
Integer i13 = -888;
int i14 =-888;
System.out.println(i13 == i14);
//基本型和封装型进行“==”运算符的比较，封装型将会自动拆箱变为基本型后再进行比较，
因此Integer会自动拆箱为int类型再进行比较，显然返回true；

⑤封装类型调用equals(),但是参数是基本类型，这时候先会进行自动装箱，基本型转换为其封装类型，再进行比较。

//--------------------------分割--------------------------------
int i=1;
int j = 2;
Integer c=3;
System.out.println(c.equals(i+j));//true
//封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，
基本型转换为其封装类型，再进行比较。