24-07-30 java八大包装类

24-07-30 java八大包装类

什么是包装类

就我粗鄙地理解来说，包装类就是把我们熟知的八大基本数据类型封装起来，加上一些方法封装成类，从而更好地开发。

包装类分类

基本数据类型与包装类的关系如下，每一种基本数据类型都有它们对应的包装类，每个类都有它们丰富的方法

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

包装类的继承体系图

在这八大包装类中，其实Byte，Short，Integer，Long，Double，Float,它们都是从Number父类继承下来的，如下图关系所示

而Character与Boolean则分别实现Serializable接口与Compareable，它们没有其他父类，只有最根本的Object父类(未显示)，如下图：

手动装箱/拆箱与自动装箱/拆箱

手动装箱/拆箱

首先我们应当先理解什么叫做装箱与拆箱，再次以鄙人粗鄙的认知来说，**装箱的意思可以理解为把基本数据类型给封装进包装类中，例如int->Integer这样中，而拆箱的意思相反，就是把基本数据类型从包装类中拿出来的意思。**那为什么分为手动与自动呢，别急，我们先来看一下手动装箱的例子；

//手动装箱
int n1 = 100;
//第一种
Integer i = new Integer(n1);
//第二种
Integer i1 = Integer.valueOf(n1);

我们就上面第一种来说，想要把int类型的n1封装进包装类中，我们需要先new一个Integer的对象，然后把int类型传进去，调用构造函数创建一个Integer对象，巨麻烦，然后我们再来看第二种方法，第二种方法从形式上来看好像是调用了Interger的静态方法，要想搞清楚怎么回事，我们需要先看一下源码。

下面我来解释一下这段代码，我们传入一个int类型的参数，然后if语句会先判断这个数在不在范围内,也就是是不是大于low，小于high（偷偷告诉你，这段范围是**-128~127**,从源码也可以看出）,所以这句话的意思是，如果我们传入的参数在-128到127的话，就会从cache中拿出一个这样的数。cache数组是一个int类型的数组，从-128-127，这样就不会在return new Integer(i)了，不会再重新创建一个新的对象，再回帖看上面的代码我们就可以理解了，不过是调用Integer类中的valueOf函数创建并返回一个对象罢了。

我们再来看手动拆箱

//手动装箱
int n1 = 100;
Integer i1 = Integer.valueOf(n1);
//手动拆箱
int n2 = i.intValue();

intValue又是什么，继续看源码

竟然这么简单，原来intValue代码就是把封装类的int类型的value返回出去，是不是很简单。

自动装箱/拆箱

但无论是上面的那种方法都很繁琐，都需要调用封装类的方法，有没有更简单一点的呢，当然有，如下：

//自动装箱
Integer integer2 = n1;
//自动拆箱
int n3 = integer2;

没想到进入可以直接把int类型的值赋值给封装类，这完全是不符合语法的呀，然而，在JDK1.5以后这种方法同样被支持，其本质也就是在底层调用刚刚手动装箱的valueof方法，拆箱也一样，本质是在底层调用了intValue方法，这些都可以通过调试发现它们的真面目。

包装类与String类的转换

下面我们来说一下包装类与String类的转换，下面以Integer为例。

将Interger转为String有三种方法，如下：

//method1
String str1 = integer + "";
//method2
String str2 = integer.toString();
//method3
String str3 = String.valueOf(integer);

将String转integer有两种方法，如下：

//method1
String str4 = "123456";
Integer integer1 = Integer.parseInt(str4);
//method2
Integer i = new Integer(str4);

大致也就是要么通过对应参数的构造函数，要么是通过类方法。

包装类的方法

上面我说过，包装类蕴含着丰富的方法，下面我们以Integer和Character的一些方法举例子。

public class WrapperMethod {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);//返回最小值
        System.out.println(Integer.MAX_VALUE);//返回最大值
        System.out.println(Character.isDigit('a'));//判断是不是数字
        System.out.println(Character.isLetter('3'));//判断是不是字母
        System.out.println(Character.isUpperCase('a'));//判断是不是大写
        System.out.println(Character.isLowerCase('a'));//判断是不是小写
        System.out.println(Character.toUpperCase('a'));//转大写
        System.out.println(Character.toLowerCase('a'));//转小写
        System.out.println(Character.isWhitespace(' '));//判断是不是空格
    }
}

包装类相关习题

Exercise01.java

public class WrapperExercise01 {
    public static void main(String[] args) {
        Double d = 100d;
        //Double d = Double.valueOf(100d);
        Float f =1.5f;
        //Float f = Float.valueOf(1.5f);
        Object object1 = true ? new Integer(1):new Double(2.0);
        System.out.println(object1);
    }
}

这里唯一需要注意的一点就是，注意要把三元运算符当做一个整体，所以会造成精度提升，最后输出的是1.0；

Exercise02.java

public class WrapperExercise02 {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer i1 = new Integer(1);
        System.out.println(i.equals(i1));

        Integer i2 = 1;
        Integer i3 = 1;
        System.out.println(i2.equals(i3));

        Integer i4 = 128;
        Integer i5 = 128;
        System.out.println(i4 == i5);
    }
}

这里需要注意的是，equals验证的是值相等不相等，而==验证的是两个对象的地址相等不相等，以及我刚刚说的valueOf函数，参入不同的值决定是否新创建一个对象。

最后的结果是

true

true

false

Exercise03.java

public class WrapperExercise03 {
    public static void main(String[] args) {
        Integer i = new Integer(127);
        Integer i1 = new Integer(127);
        System.out.println(i == i1);

        Integer i2 = new Integer(128);
        Integer i3 = new Integer(128);
        System.out.println(i2 == i3);

        Integer i4 = 127;
        Integer i5 = 127;
        System.out.println(i4 == i5);

        Integer i6 = 128;
        Integer i7 = 128;
        System.out.println(i6 == i7);

        Integer i8 = 127;
        Integer i9 = new Integer(127);
        System.out.println(i8 == i9);

        Integer i10 = 127;
        int i11 = 127;
        System.out.println(i10 == i11);

        Integer i12 = 128;
        int i13 = 128;
        System.out.println(i12 == i13);
    }
}

还是那句话，equals验证的是值相等不相等，而==验证的是两个对象的地址相等不相等，传入127与传入128有着本质区别，传入127会直接返回catch数组里面的。但是传入128会直接新建一个对象返回。

最后的结果是

false
false
true
false
false
true
true

public class WrapperExercise03 {
    public static void main(String[] args) {
        Integer i = new Integer(127);
        Integer i1 = new Integer(127);
        System.out.println(i == i1);

        Integer i2 = new Integer(128);
        Integer i3 = new Integer(128);
        System.out.println(i2 == i3);

        Integer i4 = 127;
        Integer i5 = 127;
        System.out.println(i4 == i5);

        Integer i6 = 128;
        Integer i7 = 128;
        System.out.println(i6 == i7);

        Integer i8 = 127;
        Integer i9 = new Integer(127);
        System.out.println(i8 == i9);

        Integer i10 = 127;
        int i11 = 127;
        System.out.println(i10 == i11);

        Integer i12 = 128;
        int i13 = 128;
        System.out.println(i12 == i13);
    }
}

还是那句话，equals验证的是值相等不相等，而==验证的是两个对象的地址相等不相等，传入127与传入128有着本质区别，传入127会直接返回catch数组里面的。但是传入128会直接新建一个对象返回。

最后的结果是

false
false
true
false
false
true
true

欢迎补充。。。。