Java基础(十四)：包装类

---

一、为什么需要包装类

• Java提供了两个类型系统，基本数据类型与引用数据类型
• 使用基本数据类型在于效率，然而当要使用只针对对象设计的API或新特性（例如泛型），怎么办呢？

//情况1：方法形参
Object类的equals(Object obj)

//情况2：方法形参
ArrayList类的add(Object obj)
//没有如下的方法：
add(int number)
add(double d)
add(boolean b)

//情况3：泛型
Set<T>
List<T>
Cllection<T>
Map<K,V>

二、有哪些包装类

• Java针对八种基本数据类型定义了相应的引用类型：包装类（封装类）

封装以后的，内存结构对比：

public static void main(String[] args){
	int num = 520;
	Integer obj = new Integer(520);
}

自定义包装类

public class MyInteger {
    int value;

    public MyInteger() {
    }

    public MyInteger(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

三、包装类与基本数据类型间的转换

1、装箱

• 装箱：把基本数据类型转为包装类对象
• 转为包装类的对象，是为了使用专门为对象设计的API和特性
• 基本数值---->包装对象：（包装类中的valueOf()方法）

Integer obj1 = new Integer(4);//使用构造函数函数
Float f = new Float(“4.56”);
Long l = new Long(“asdf”);  //NumberFormatException

Integer obj2 = Integer.valueOf(4);//使用包装类中的valueOf方法

2、拆箱

• 拆箱：把包装类对象拆为基本数据类型
• 转为基本数据类型，一般是因为需要运算，Java中的大多数运算符是为基本数据类型设计的。比较、算术等
• 包装对象---->基本数值：（包装类对象的xxxValue()方法）

Integer obj = new Integer(4);
int num1 = obj.intValue();

3、自动装箱与拆箱

• 由于我们经常要做基本类型与包装类之间的转换
• 从JDK5.0 开始，基本类型与包装类的装箱、拆箱动作可以自动完成

例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象

• 注意：只能与自己对应的类型之间才能实现自动装箱与拆箱

Integer i = 1;
Double d = 1;//错误的，1是int类型

四、基本数据类型、包装类与字符串间的转换

1、基本数据类型转为字符串

• 方式1：调用字符串重载的valueOf()方法

int a = 10;
//String str = a;//错误的

String str = String.valueOf(a);

• 方式2：更直接的方式

int a = 10;

String str = a + "";

2、字符串转为基本数据类型

• 包装类的parseXxx静态方法
  • public static int parseInt(String s)：将字符串参数转换为对应的int基本类型
  • public static long parseLong(String s)：将字符串参数转换为对应的long基本类型
  • public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型

int a = Integer.parseInt("整数的字符串");
double d = Double.parseDouble("小数的字符串");
boolean b = Boolean.parseBoolean("true或false");

• Character特殊，没有parse方法
  • str.charAt(0)：获取字符串对应角标位置的字符
  • str.toCharArray()：获取字符串所有字符分别组合成的数组

String str ="CSDN";
//方法一
char c1 = str.charAt(0);
System.out.println(c1);
//方法二
char[] value = str.toCharArray();
char c2=value[1];
System.out.println(c2);

3、字符串转为包装类

• 包装类的valueOf静态方法
  • public static Integer valueOf(String s)：将字符串参数转换为对应的Integer包装类
  • public static Long valueOf(String s)：将字符串参数转换为对应的Long包装类
  • public static Double valueOf(String s)：将字符串参数转换为对应的Double包装类

int a = Integer.valueOf("整数的字符串");
double d = Double.valueOf("小数的字符串");
boolean b = Boolean.valueOf("true或false");

4、通过包装类的构造器实现

int i = new Integer(“12”);

其他方式小结：

五、包装类的其它API

1、 数据类型的最大最小值

Integer.MAX_VALUE和Integer.MIN_VALUE
    
Long.MAX_VALUE和Long.MIN_VALUE
    
Double.MAX_VALUE和Double.MIN_VALUE

2、字符转大小写

Character.toUpperCase('x');

Character.toLowerCase('X');

3、整数转进制

Integer.toBinaryString(int i) 
    
Integer.toHexString(int i)
    
Integer.toOctalString(int i)

4、比较的方法

Double.compare(double d1, double d2)
    
Integer.compare(int x, int y) 

六、包装类对象的特点

1、包装类缓存对象

包装类	缓存对象
Byte	-128~127
Short	-128~127
Integer	-128~127
Long	-128~127
Float	没有
Double	没有
Character	0~127
Boolean	true和false

示例：

Integer a = 1;
Integer b = 1;
System.out.println(a == b);//true

Integer i = 128;
Integer j = 128;
System.out.println(i == j);//false

Integer m = new Integer(1);//新new的在堆中
Integer n = 1;//这个用的是缓冲的常量对象，在方法区
System.out.println(m == n);//false

Integer x = new Integer(1);//新new的在堆中
Integer y = new Integer(1);//另一个新new的在堆中
System.out.println(x == y);//false

Double d1 = 1.0;
Double d2 = 1.0;
System.out.println(d1==d2);//false 比较地址，没有缓存对象，每一个都是新new的

2、类型转换问题

Integer i = 1000;
double j = 1000;
System.out.println(i==j);//true  会先将i自动拆箱为int，然后根据基本数据类型“自动类型转换”规则，转为double比较

Integer i = 1000;
int j = 1000;
System.out.println(i==j);//true 会自动拆箱，按照基本数据类型进行比较

Integer i = 1;
Double d = 1.0
System.out.println(i==d);//编译报错

3、包装对象不可变

public class TestExam {
	public static void main(String[] args) {
		int i = 1;
		Integer j = new Integer(2);
		Circle c = new Circle();
		change(i,j,c);
		System.out.println("i = " + i);//1
		System.out.println("j = " + j);//2
		System.out.println("c.radius = " + c.radius);//10.0
	}
	
	/*
	 * 方法的参数传递机制：
	 * （1）基本数据类型：形参的修改完全不影响实参
	 * （2）引用数据类型：通过形参修改对象的属性值，会影响实参的属性值
	 * 这类Integer等包装类对象是“不可变”对象，即一旦修改，就是新对象，和实参就无关了
	 */
	public static void change(int a ,Integer b,Circle c ){
		a += 10;
//		b += 10;//等价于  b = new Integer(b+10);
		c.radius += 10;
		/*c = new Circle();
		c.radius+=10;*/
	}
}
class Circle{
	double radius;
}