20. 包装类
20.1 为什么需要包装类
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>
20.2 有哪些包装类
Java针对八种基本数据类型定义了相应的引用类型 包装类(封装类)。有了类的特点,就可以调用类中的方法,Java才是真正的面向对象。
封装以后的,内存结构对比
public static void main(String[] args){
int num = 520;
Integer obj = new Integer(520);
}
20.3 自定义包装类
public class MyInteger {
int value;
public MyInteger() {
}
public MyInteger(int value) {
this.value = value;
}
@Override
public String toString() {
return String.valueOf(value);
}
}
20.4 包装类与基本数据类型间的转换
20.4.1 装箱
装箱 把基本数据类型转为包装类对象
转为包装类的对象,是为了使用专门为对象设计的API和特性
基本数值---->包装对象
Integer obj1 = new Integer(4);//使用构造函数函数
Float f = new Float(“4.56”);
Long l = new Long(“asdf”); //NumberFormatException
Integer obj2 = Integer.valueOf(4);//使用包装类中的valueOf方法
20.4.2 拆箱
拆箱 把包装类对象拆为基本数据类型
转为基本数据类型,一般是因为需要运算,Java中的大多数运算符是为基本数据类型设计的。比较、算术等
包装对象---->基本数值
Integer obj = new Integer(4);
int num1 = obj.intValue();
自动装箱与拆箱:
由于我们经常要做基本类型与包装类之间的转换,从JDK5.0
开始,基本类型与包装类的装箱、拆箱动作可以自动完成。例如
Integer i = 4; //自动装箱 相当于Integer i = Integer.valueOf(4);
i = i + 5; //等号右边 将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后,再次装箱,把基本数值转成对象。
int b = i; //自动拆箱
System.out.println(i.equals(9)); //true
注意 只能与自己对应的类型之间才能实现自动装箱与拆箱。
Integer i = 1;
Double d = 1;//错误的,1是int类型
20.5 基本数据类型、包装类与字符串间的转换
(1)基本数据类型转为字符串
方式1 :调用字符串重载的valueOf()方法
int a = 10;
Integer i = 20;
//String str = a;//错误的
String str = String.valueOf(a);
String str1 = String.valueOf(i); //自动装箱
String str2 = i.toString();
String str3 = Integer.toString(i);
方式2 : 更直接的方式
int a = 10;
String str = a + "";
(2)字符串转为基本数据类型
方式1:除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型,例如
public static int parseInt(String s)
将字符串参数转换为对应的int基本类型。public static long parseLong(String s)
将字符串参数转换为对应的long基本类型。public static double parseDouble(String s)
将字符串参数转换为对应的double基本类型。
方式2:字符串转为包装类,然后可以自动拆箱为基本数据类型
public static Integer valueOf(String s)
将字符串参数转换为对应的Integer包装类,然后可以自动拆箱为int基本类型public static Long valueOf(String s)
将字符串参数转换为对应的Long包装类,然后可以自动拆箱为long基本类型public static Double valueOf(String s)
将字符串参数转换为对应的Double包装类,然后可以自动拆箱为double基本类型
注意:如果字符串参数的内容无法正确转换为对应的基本类型,则会抛出java.lang.NumberFormatException
异常。
方式3:通过包装类的构造器实现
int i = new Integer(“12”);
/* java.lang.NumberFormatException
int a = Integer.parseInt("整数的字符串");
double d = Double.parseDouble("小数的字符串");
boolean b = Boolean.parseBoolean("true或false");
int a = Integer.valueOf("整数的字符串");
double d = Double.valueOf("小数的字符串");
boolean b = Boolean.valueOf("true或false");
*/
20.6 包装类的其它API
20.6.1 数据类型的最大最小值
Integer.MAX_VALUE和Integer.MIN_VALUE
Long.MAX_VALUE和Long.MIN_VALUE
Double.MAX_VALUE和Double.MIN_VALUE
20.6.2 字符转大小写
Character.toUpperCase('x');
Character.toLowerCase('X');
20.6.3 整数转进制
Integer.toBinaryString(int i)
Integer.toHexString(int i)
Integer.toOctalString(int i)
20.6.4 比较的方法
Double.compare(double d1, double d2)
Integer.compare(int x, int y)
20.7 包装类对象的特点
20.7.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的
20.7.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);//编译报错
20.7.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;
}
20.8 练习
笔试题 如下两个题目输出结果相同吗?各是什么。
Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);//1.0
1、JVM在编译Java代码时会自动将包装类型转换为基本数据类型,即为拆箱;
2、int自动提升为double
3、装箱成Double
4、多态:父类的对象,指向子类的引用,即Object类型的对象obj1指向Double对象的引用,
Double重写了Object的toString()方法,调用了Double重写后的toString()方法
5、最终输出结果是1.0
Object o2;
if (true)
o2 = new Integer(1);
else
o2 = new Double(2.0);
System.out.println(o2);//1