java -- 包装类

什么是包装类

包装类可以简单理解为对基本数据类型的功能拓展，最终以封装为class的形式呈现。这是因为八大基本数据类型只能完成基本的算术或逻辑操作，无法实现诸如“字符串转换”等特殊操作。在以上背景下，包装类应运而生。

包装类分类

根据八大基本数据类型，包装类相应的可以分为八类，具体如下：

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

包装类详解（以Integer为例）

所在包

该类位于java.lang包下，使用时无需导包。

简述

先看一段JDK关于Integer的注释

/**
 * The {@code Integer} class wraps a value of the primitive type
 * {@code int} in an object. An object of type {@code Integer}
 * contains a single field whose type is {@code int}.
 *
 * <p>In addition, this class provides several methods for converting
 * an {@code int} to a {@code String} and a {@code String} to an
 * {@code int}, as well as other constants and methods useful when
 * dealing with an {@code int}.
 */

大体上是说，这是一个包含唯一类字段的类；类字段为int型，用来存储int型变量。除此之外，该类还提供了一些诸如int与String之间相互转换的方法，用于实现一些常见操作。

构造方法

有2个有参构造方法，分别为：Integer(int)和Integer(String)。JDK源码如下：

 /**
     * Constructs a newly allocated {@code Integer} object that
     * represents the specified {@code int} value.
     *
     * @param   value   the value to be represented by the
     *                  {@code Integer} object.
     */
    public Integer(int value) {
        this.value = value;
    }

/**
     * Constructs a newly allocated {@code Integer} object that
     * represents the {@code int} value indicated by the
     * {@code String} parameter. The string is converted to an
     * {@code int} value in exactly the manner used by the
     * {@code parseInt} method for radix 10.
     *
     * @param      s   the {@code String} to be converted to an
     *                 {@code Integer}.
     * @exception  NumberFormatException  if the {@code String} does not
     *               contain a parsable integer.
     * @see        java.lang.Integer#parseInt(java.lang.String, int)
     */
    public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10);
    }

首先来看Integer(int)，该方法是根据一个形参int实例化一个Integer对象，内部细节就是将形参int赋值给Integer的类字段value。

再来看Integer(String)，该方法使用一个String类型对象实例化Integer。内部实现稍微复杂一点点，先是用Integer静态成员方法将String转化为对应int值，然后再将获得的int值赋值给Integer类字段value。

成员方法

由于在实际开发中，我们用的最多的无非就是String与int的相互转化。因此，接着来我们主要总结一下这方面的成员方法。

用途	静态成员方法	非静态成员方法
String –> int	parseInt(String s) parseInt(String s, int radix)
int –> String	toString(int i) toString(int i, int radix)
String –> Integer	valueOf(String s) valueOf(String s, int radix)
Integer –> String		toString()
int –> Integer	valueOf(int i)
Integer –> int		intValue()

另外，在阅读Integer源码中，发现了两个好玩的成员方法reverse(int i)和rotateLeft(int i, int distance)，其中对于bit的操作很有启发性，现直接将源码贴在下方：

/**
    * Returns the value obtained by reversing the order of the bits in the
    * two's complement binary representation of the specified {@code int}
    * value.
    *
    * @param i the value to be reversed
    * @return the value obtained by reversing order of the bits in the
    *     specified {@code int} value.
    * @since 1.5
    */
   public static int reverse(int i) {
       // HD, Figure 7-1
       // 举个例子：对于一个字节"abcdefgh"
       i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555; // abcd efgh --> badc fehg
       i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333; // badc fehg --> dcba hgfe
       i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f; // dcba hgfe --> hgfe dcba
       // 下面是完成4个字节的反向 1 <--> 4  以及  2 <--> 3
       i = (i << 24) | ((i & 0xff00) << 8) |
           ((i >>> 8) & 0xff00) | (i >>> 24);
       return i;
   }


 /**
    * Returns the value obtained by rotating the two's complement binary
    * representation of the specified {@code int} value left by the
    * specified number of bits.  (Bits shifted out of the left hand, or
    * high-order, side reenter on the right, or low-order.)
    *
    * <p>Note that left rotation with a negative distance is equivalent to
    * right rotation: {@code rotateLeft(val, -distance) == rotateRight(val,
    * distance)}.  Note also that rotation by any multiple of 32 is a
    * no-op, so all but the last five bits of the rotation distance can be
    * ignored, even if the distance is negative: {@code rotateLeft(val,
    * distance) == rotateLeft(val, distance & 0x1F)}.
    *
    * @param i the value whose bits are to be rotated left
    * @param distance the number of bit positions to rotate left
    * @return the value obtained by rotating the two's complement binary
    *     representation of the specified {@code int} value left by the
    *     specified number of bits.
    * @since 1.5
    */
   public static int rotateLeft(int i, int distance) {
       return (i << distance) | (i >>> -distance);
       // i >>> -distance 意思是
       // 如果 distance > 0: i >>> -distance = i >>> (32-(distance % 32)) 
       // 如果 distance < 0: 与普通 i >>> 正数 并无二致
   }