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

落日映苍穹つ 2021-10-01 12:24 301阅读 0赞

### 1. 导读 ###

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

### 2. 什么包装类 ###

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

<table> 
 <thead> 
  <tr> 
   <th>基本类型</th> 
   <th>封装类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Char</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

其实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()));
        }

![16020996-8e10886788cd5e26.png][]

通过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的结果是一样的;

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

[16020996-8e10886788cd5e26.png]: /images/20210809/173d57161b0c47028c405a4039f25ef8.png