您的位置: 首页  >  文章  >  Java基础之神奇的包装类(一)

Java基础之神奇的包装类(一)

分类: 文章 • 2024-09-02 09:56:40

文章目录

1. 导读

JAVA中针对八种基本数据类型提供了相对应的包装类, 今天主要基于几个问题来分享下个人对于包装类的理解, 本期先分享下面两个问题:
.1 什么是包装类? 有了基本类型, 为什么还需要有包装类;
.2 包装类干了什么?

2. 什么包装类

众所周知, JAVA提供了八种基本类型, 同时也对这八种基本类型做了相应的封装, 形成了八种包装类:

基本类型 封装类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

其实void在JAVA也是一种数据类型, 也有对应的包装类Void, 只是我们无法对其进行操作, 也就没有放在上面的表格中了;

3. 为什么需要包装类

JAVA是面相对象的编程语言; 那么要理解面相对象, 首先需要知道这个对象是什么? 我的理解是:
.1 对象具有自己的属性以及行为;
.2 对象可以通过自己的行为或者动作向外界传递信息;
那么面相对象就是通过对象之间的信息交互来实现整个程序的功能; 而封装, 继承 和 多态是语言层面的强制约束;
有了面相对象编程的概念, 我们再来看为什么JAVA需要包装类;
.1 包装类在基本类型的基础上做了封装, 使其有了自身的行为; 那么有了行为有什么好处呢? 我们举个例子来说明:

    public static void main(String[] args) {
		int simpleData = 1;
		Integer wrapperData = 1;
		LOGGER.info(String.format("基本类型的比较结果:%s", simpleData == wrapperData));
		LOGGER.info(String.format("包装类型的比较结果:%s", wrapperData.equals(simpleData)));
		LOGGER.info(String.format("基本类型转String:%s", String.valueOf(simpleData)));
		LOGGER.info(String.format("包装类型转String:%s", wrapperData.toString()));
	}

Java基础之神奇的包装类(一)
通过int和Integer举例, 展示了基本类型和包装类型的判断和转String的区别:为什么达到同一个目的, 基本类型需要借助其他手段来实现; 而包装类却可以通过自身的动作达到, 这就是基本类型和包装类型的不同, 这也是面相过程与面相对象的区别: 面相过程需要自己实现需求, 面相对象则是调用目标对象对应的方法即可;

.2 初始化的不同: 未赋值时, 基本数据类型默认是0, 而封装类型默认是null; 当需要区分赋值与未赋值时, 封装类型就显得十分友好了; 比如在构建更新实体时, 有个字段是0, 就需要判断他的原始值是0还是需要更新成0; 而null则没有这种烦恼了;

.3 前面说过JAVA是面相对象的语言, 其很多设计都是针对对象来的, 比如HashMap的设计, 在插入时, 需要先调用插入key的Object::equals, 但是基本数据类型是没有行为的, 意味着基本数据类型无法作为HashMap的key; 如果没有封装类, 我们就无法实现用数值类型作为key了;

故而为何需要封装类?
.1 JAVA是面相对象的语言, 其语言设计初衷就需要"万物皆对象", 故需要对基本数据类型再次封装;
.2 JAVA内部很多实现需要调用对象相对应的动作, 而基本数据类型不是对象, 为了使用这些实现, 需要封装对象;

4. 包装类干了什么

这8个包装类大同小异, 我们以比较特殊的Integer来举例;

    public final class Integer extends Number implements Comparable<Integer> {
    /**
     * A constant holding the minimum value an {@code int} can
     * have, -2<sup>31</sup>.
     */
    @Native public static final int   MIN_VALUE = 0x80000000;

    /**
     * A constant holding the maximum value an {@code int} can
     * have, 2<sup>31</sup>-1.
     */
    @Native public static final int   MAX_VALUE = 0x7fffffff;
    ...
     /**
     * The value of the {@code Integer}.
     *
     * @serial
     */
    private final int value;

从上面的代码可看出, Integer的一些设计:
.1 Integer类是final的, 其底层存值的value也是final的; 这个设计和String是一样的, Integer也就是不可变的;
.2 Integer也设置了int相同的最大最小值, 因为Integer是基于int做的封装, 故而仍然存在溢出问题(当赋的值大于Integer.MAX_VALUE时, 发生溢出);

再来关注下Integer::equals, Integer重写了Object的equals方法:

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

.1 如果传入对象是Integer类型的, 比较两者的value是相等;
.2 如果是非Integer类型的, 直接返回false;
.3 这里没有先比对两者的堆地址, 因为只有两者是同一个对象时才会直接返回true; 这个概率比较小(一般没人会自己比较自己吧), 所以直接省略了这一步;

继续关注Integer::hashCode的实现:

    public static int hashCode(int value) {
        return value;
    }

Integer::hashCode直接返回了当前的值(hashCode返回的是个int类型的值, 直接返回Integer的值好像也没啥不对);
按这个逻辑, Long::hashCode是不是直接强转成int返回的呢? 因为精度问题, Long::hashCode做了特殊处理:

    public static int hashCode(long value) {
        return (int)(value ^ (value >>> 32));
    }

Long::hashCode并不是如我们猜想的那样设计的:
.1 先把value右移32位, 因为long是64位的, 右移32位就把左边边的值都置为0了;
.2 再与原始值进行异或, 将得出的结果强转成int类型;
.3 至于为什么这么设计, 主要是以为int是32位的, 如果采用Integer::hashCode的方法, 那么当右边32位都是0时, 不管左边的32位是何值, 在转为int时, 左边32位都被摸除, 得出的结果都是0; 这样的方式显然会有很大的碰撞;
.4 故而Long::hashCode采用了低位32异或高位32的方式来获取hashCode;Double::hashCode的实现也是采用的这种方式;

Integer是实现了Compareable接口的, 我们来看下Integer::compareTo:

     public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

.1 使用了三目运算符; 第一层先判断是否小于, true则返回-1;
.2 第二层判断是否相等, true则返回0, 反之则返回1;
.3 如果两个Integer是相等的, 那么调用Integer::equals 和 Integer::compareTo的结果是一样的;

本期基于上面两个问题分享了个人对于封装类的理解, 如果上面有不当之处, 欢迎指正; 如果看了觉的有益处, 烦请点赞转发吧, 感谢;

相关推荐