【JavaSe】常用API篇(九) 包装类

JavaSe·常用API篇(九) 包装类

---

1.概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

除了Integer和Character类以后，其它六个类的类名和基本数据类型一样，只是首字母大写。

2. 包装类的作用

1、 八大数据类型的操作就可以像操作对象一样操作。
2、 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。
3、 基本类型和包装类之间可以互相转换。
4、 通过包装类，String可以和基本类型之间相互转换。
5、 集合不允许存放基本数据类型，故常用包装类

3. 装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

• 装箱：从基本类型转换为对应的包装类对象。
• 拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

int num = i.intValue();

4. 自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。

直接赋值：自动装箱和拆箱能像基本数据类型一样直接赋值，无需自己去创建包装类对象。

/*
 装箱
 */
// jdk1.5以前，需手动装箱
Integer a = new Integer(23);
// jdj1.5以后，自动装箱
Integer b = 23;
/* 
   拆箱
 */
// jdk1.5以前，需手动拆箱
int a1 = a.intValue();
// jdk1.5以后，自动拆箱
int b1 = b;

做运算：对象之间不能使用+、-、*、/等运算符，包装类对象自动拆箱便可以了

/*
 * 装箱
 */
Integer a = new Integer(23);
Integer b = new Integer(3);
// jdk1.5之前，包装类对象不能直接做运算
// jdk1.5之后，能直接做运算
int c = a + b;
Integer d = a + c;

方法调用传参上：方法调用传参时，我们可以传入原始数据值或者对象，编译器和自动转换

// 参数列表要求传的是int类型
public static int zhuangXiang(int i) {
	return i;
}
// 参数列表要求传的是Integer包装类对象
public static Integer chaiXiang(Integer i) {
	return i;
}
/*
 * 装箱
 */
// 调用zhuangXiang方法，传入的是Integer包装类对象
Integer a = new Integer(23);
// 传入的时候自动转成了所要求的int数据类型
int b = zhuangXiang(a);
/*
 * 拆箱 
 */
// 调用chaiXiang方法，传入的是int数据类型
int c = 23;
// 传入的时候自动转成了所要求的Integer包装类的对象
Integer d = chaiXiang(c);

编译器在直接赋值、做运算、方法调用传参上的时候能自动装箱和拆箱。

自动装拆箱的原理：

• 自动装箱时，编译器自动执行了valueOf()方法，将基本数据类型转成了包装类对象。
• 自动拆箱时，编译器自动执行了xxxValue()方法，将包装类对象转成了基本数据类型。

所以，自动装箱有一个弊端：
每次自动装箱时都会隐式地创建对象，比如在一个循环体中，用包装类对象去做运算，会创建很多无用的中间对象，会降低程序的性能以及加重了垃圾回收的工作量。因此在我们编程时，需要注意到这一点，正确地声明变量类型，避免因为自动装箱引起的性能问题。

5. 包装类与基本数据类型区别

1. 声明方式不同：基本类型不使用new关键字，而包装类型需要使用new关键字来在堆中分配存储空间；
2. 存储方式及位置不同：基本类型是直接将变量值存储在栈中，而包装类型是将对象放在堆中，然后通过引用来使用；
3. 初始值不同：基本类型的初始值如int为0，boolean为false，而包装类型的初始值为null；
4. 使用方式不同：基本类型直接赋值直接使用就好，而包装类型在集合时会使用到。

6. 基本类型与字符串之间的转换

6.1 字符串 ----> 基本数据类型

调用包装类中的parseXxx方法

方法：

//xxx指的是基本数据类型，char除外
public static xxx parseXxx(String s);

特点：

• 静态方法，直接xxx的包装类.parseXxx(“…”)调用，返回xxx数据类型。
• 参数将转为整数和浮点数据类型时，如果传入的字符串参数是null、非一串数字会报NumberFormatException异常。
• String转boolean类型：若字符串为“true”，则返回true；否则返回false。

// String ----> int
int a = Integer.parseInt("23");
System.out.println(a); // 23

// String ----> double
double b = Double.parseDouble("23");
System.out.println(b); // 23.0

// String ----> boolean
boolean c = Boolean.parseBoolean("传true才是true!");
System.out.println(c); // false

6.2 基本数据类型 ----> 字符串

方法1：基本数据类型直接与 “ ” 相连接即可，如23+“KingJames”。
方法2：调用String的valueOf方法
方法3：调用包装类中的toString方法

特点：

• 静态方法，直接xxx的包装类.toString(x)调用，返回String数据类型。
• 注意带参数，无参的toString方法是对象方法。
• 无参数的toString方法是对象方法，表示调用该方法的对象转为String对象。
• 有参数的toString方法是静态方法，表示将参数的数据类型转为String。
• boolean转String类型：若为true，则返回“true”；若为false，则返回“false”

String a = Integer.toString(23);
System.out.println(a); // 23
// double ----> String
String b = Double.toString(23.0);
System.out.println(b); // 23.0
// boolean ----> String
String c = Boolean.toString(true);
System.out.println(c); // true

7. 基本类型与包装对象互转

7.1 基本数据类型 ----> 包装对象：

方法1：包装类构造方法
方法2：静态的valueOf方法

方法：

• 包装类构造器：
  • public Xxx(xxx value) （xxx指的八大基本数据类型）
  • public Xxx(String s) （同上，但char除外）
• 包装类的valueOf方法
  • public static xxx valueOf(xxx x) （xxx指的八大基本数据类型）
  • public static xxx valueOf(String s) （同上，但char除外）

特点：

• 通过new建立对象或者直接包装类名.valueOf方法调用。
• char数据类型不能使用带String参数的方法来转换。
• boolean转Boolean包装类型：若为 “true”，则分配true；否则返回false

// 以Integer为例，创建实例对象。
Integer a1 = new Integer(23);
Integer a2 = new Integer("23");
Integer a3 = Integer.valueOf(23);
Integer a4 = Integer.valueOf("23");

7.2 包装对象 ----> 基本数据类型

调用包装类的xxxValue()方法

方法：

// xxx指的八大基本数据类型
public xxx xxxValue();

特点：

• 非静态方法，需要有对象来调用，用xxx包装类的对象.xxxValue()来调用。

// Integer ----> int
Integer a1 = Integer.valueOf(23);
int a2 = a1.intValue();
// Double ----> double
Double b1 = Double.valueOf(23.0);
double b2 = b1.doubleValue();
// Boolean ----> boolean
Boolean c1 = Boolean.valueOf(true);
boolean c2 = c1.booleanValue();