java封装数据类型——Integer

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

今天来学习整型 int 的封装数据类型，Integer。

1. 定义

首先来看看定义。可以看到，Integer 继承 Number 抽象类，实现了 Comparable 接口。Number 类是常用数字类型类的公共父类，它规定了其子类（通常就是数字类）必须提供将其值转换成 int、long、float、double、byte、short 类型数据的能力。实现 Comparable 接口自然是为了比较大小。另外，Integer 类型也是最终类，不可被继承（事实上，常用数据类型的封装类都是 final 类）。

2. 属性

2.1. 表示 int 数据类型上下界值的字段：MIN_VALUE = -2 ³¹ ，MAX_VALUE = 2 ³¹ -1 ；

2.2. Integer 类型类对象的引用：TYPE；

3. 构造方法

Integer 提供两个构造方法，分别接收一个 int 数据类型和一个 string 类型（不是整数会报错）。

    public Integer(int value) {

            this.value = value;

    }

    public Integer(String s) throws NumberFormatException {

        this.value = parseInt(s, );

    }

4. 普通方法

`static int`	`bitCount(int i)` 返回指定的int值的二进制补码二进制表示中的 `int` 数。
`byte`	`byteValue()` 返回此值 `Integer` 为 `byte` 的基本收缩转换后。
`static int`	`compare(int x, int y)` 比较两个 `int` 数字值。
`int`	`compareTo(Integer anotherInteger)` 数字比较两个 `Integer` 对象。
`static int`	`compareUnsigned(int x, int y)` 比较两个 `int` 值，以数值方式将值视为无符号。
`static Integer`	`decode(String nm)` 将 `String` 解码成 `Integer` 。
`static int`	`divideUnsigned(int dividend, int divisor)` 返回将第一个参数除以秒的无符号商，其中每个参数和结果被解释为无符号值。
`double`	`doubleValue()` 返回此值 `Integer` 为 `double` 一个宽元转换后。
`boolean`	`equals(Object obj)` 将此对象与指定的对象进行比较。
`float`	`floatValue()` 返回此值 `Integer` 为 `float` 一个宽元转换后。
`static Integer`	`getInteger(String nm)` 确定具有指定名称的系统属性的整数值。
`static Integer`	`getInteger(String nm, int val)` 确定具有指定名称的系统属性的整数值。
`static Integer`	`getInteger(String nm, Integer val)` 返回具有指定名称的系统属性的整数值。
`int`	`hashCode()` 返回这个 `Integer` 的哈希码。
`static int`	`hashCode(int value)` 返回值为 `int` 的哈希码; 兼容 `Integer.hashCode()` 。
`static int`	`highestOneBit(int i)` 返回一个 `int` 值与至多一个单个1位，在最高阶（“最左侧”）的位置在指定的一个位 `int` 值。
`int`	`intValue()` 将 `Integer` 的值作为 `int` 。
`long`	`longValue()` 返回此值 `Integer` 为 `long` 一个宽元转换后。
`static int`	`lowestOneBit(int i)` 在指定的 `int` 值中，以最低位（最右边）为1位返回一个最多为单个1位的 `int` 值。
`static int`	`max(int a, int b)` 返回两个 `int` 的较大值，就像调用 `Math.max` 一样。
`static int`	`min(int a, int b)` 返回两个 `int` 的较小值，就像调用 `Math.min` 一样。
`static int`	`numberOfLeadingZeros(int i)` 返回的最高阶的（“最左边的”）中所指定的二进制补码表示的一个位前述零个比特的数量 `int` 值。
`static int`	`numberOfTrailingZeros(int i)` 返回零位以下最低阶（“最右边的”）的数量在指定的二进制补码表示的一个位 `int` 值。
`static int`	`parseInt(String s)` 将字符串参数解析为带符号的十进制整数。
`static int`	`parseInt(String s, int radix)` 将字符串参数解析为第二个参数指定的基数中的有符号整数。
`static int`	`parseUnsignedInt(String s)` 将字符串参数解析为无符号十进制整数。
`static int`	`parseUnsignedInt(String s, int radix)` 将字符串参数解析为第二个参数指定的基数中的无符号整数。
`static int`	`remainderUnsigned(int dividend, int divisor)` 返回无符号余数，将第一个参数除以秒，其中每个参数和结果被解释为无符号值。
`static int`	`reverse(int i)` 返回由指定的二进制补码表示反转位的顺序而获得的值 `int` 值。
`static int`	`reverseBytes(int i)` 返回反转指定的二进制补码表示的字节顺序而获得的值 `int` 值。
`static int`	`rotateLeft(int i, int distance)` 返回通过旋转指定的二的补码的二进制表示而得到的值 `int` 由位指定数目的左值。
`static int`	`rotateRight(int i, int distance)` 返回通过旋转指定的二的补码的二进制表示而得到的值 `int` 右移位的指定数值。
`short`	`shortValue()` 返回此值 `Integer` 为 `short` 的基本收缩转换后。
`static int`	`signum(int i)` 返回指定的 `int` 值的 `int` 函数。
`static int`	`sum(int a, int b)` 根据+运算符将两个整数相加。
`static String`	`toBinaryString(int i)` 在基数2中返回整数参数的字符串表示形式为无符号整数。
`static String`	`toHexString(int i)` 返回整数参数的字符串表示形式，作为16位中的无符号整数。
`static String`	`toOctalString(int i)` 在基数8中返回整数参数的字符串表示形式为无符号整数。
`String`	`toString()` 返回 `String` 表示此对象 `Integer` 的价值。
`static String`	`toString(int i)` 返回一个 `String` 指定整数的 `String` 对象。
`static String`	`toString(int i, int radix)` 返回由第二个参数指定的基数中的第一个参数的字符串表示形式。
`static long`	`toUnsignedLong(int x)` 参数给转换 `long` 由无符号转换。
`static String`	`toUnsignedString(int i)` 将参数的字符串表示形式返回为无符号十进制值。
`static String`	`toUnsignedString(int i, int radix)` 以第二个参数指定的基数中的无符号整数值返回第一个参数的字符串表示形式。
`static Integer`	`valueOf(int i)` 返回一个 `Integer` 指定的 `int` 值的 `Integer` 实例。
`static Integer`	`valueOf(String s)` 返回一个 `Integer` 对象，保存指定的值为 `String` 。
`static Integer`	`valueOf(String s, int radix)` 返回一个 `Integer` 对象，保存从指定的String中 `String` 的值，当用第二个参数给出的基数进行解析时。

4.1. byteValue()、shortValue()、intValue()、longValue()、floatValue()、doubleValue()，这些是继承自 Number 类的方法，返回当前 Integer 对象对应 int 值对应的各种数据类型值（通过强制类型转换，强转到低精度时可能丢失数据）

4.2. compareTo(Integer) 方法

该方法接收一个被比较的 Integer 类对象，并与之比较大小，遵循 Comparable 接口的常规约定： 若当前值等于参数值，返回 0；若当前值小于参数值，返回 -1；若当前值大于参数值，返回 1；

    public int compareTo(Integer anotherInteger) {

        return compare(this.value, anotherInteger.value);

    }

    /**

     * Compares two {@code int} values numerically.

     * The value returned is identical to what would be returned by:

     * <pre>

     *    Integer.valueOf(x).compareTo(Integer.valueOf(y))

     * </pre>

     *

     * @param  x the first {@code int} to compare

     * @param  y the second {@code int} to compare

     * @return the value {@code 0} if {@code x == y};

     *         a value less than {@code 0} if {@code x < y}; and

     *         a value greater than {@code 0} if {@code x > y}

     * @since 1.7

     */

    public static int compare(int x, int y) {

        return (x < y) ? - : ((x == y) ?  : );

    }

4.3. decode(String)，解码方法，将参数字符串解码得到 Integer，该方法自动识别正负符号和进制符号（如：0x、0、# 等），如 -0xa1 = -161，默认是正数和十进制

    public static Integer decode(String nm) throws NumberFormatException {

        int radix = ;

        int index = ;

        boolean negative = false;

        Integer result;

        if (nm.length() == )

            throw new NumberFormatException("Zero length string");

        char firstChar = nm.charAt();

        // Handle sign, if present

        if (firstChar == '-') {

            negative = true;

            index++;

        } else if (firstChar == '+')

            index++;

        // Handle radix specifier, if present

        if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {

            index += ;

            radix = ;

        }

        else if (nm.startsWith("#", index)) {

            index ++;

            radix = ;

        }

        else if (nm.startsWith("", index) && nm.length() >  + index) {

            index ++;

            radix = ;

        }

        if (nm.startsWith("-", index) || nm.startsWith("+", index))

            throw new NumberFormatException("Sign character in wrong position");

        try {

            result = Integer.valueOf(nm.substring(index), radix);

            result = negative ? Integer.valueOf(-result.intValue()) : result;

        } catch (NumberFormatException e) {

            // If number is Integer.MIN_VALUE, we'll end up here. The next line

            // handles this case, and causes any genuine format error to be

            // rethrown.

            String constant = negative ? ("-" + nm.substring(index))

                                       : nm.substring(index);

            result = Integer.valueOf(constant, radix);

        }

        return result;

    }

可以看到，decode 方法首先对正负号和进制符号进行识别判断，最后将剩下的纯数值部分和得到的进制数值调用静态工厂方法 valueOf(string, int) 构造 Integer 对象。

4.4. valueOf 静态方法

Integer 类支持整型和字符串型参数的工厂方法，其中字符串型的工厂方法支持指定进制，并且会先使用 parseInt 方法解析出原始 int 数值，再通过 valueOf (int) 方法构造 Integer 对象。parseInt 方法就是遍历字符串并使用进制值加权累加计算了。最值得注意的是 int 参数的 valueOf 方法，它体现了 Integer 类的缓存策略，后面单独讲。

    public static Integer valueOf(String s, int radix) throws NumberFormatException {

        return Integer.valueOf(parseInt(s,radix));

    }

    public static Integer valueOf(String s) throws NumberFormatException {

        return Integer.valueOf(parseInt(s, ));

    }

    public static Integer valueOf(int i) {

        if (i >= IntegerCache.low && i <= IntegerCache.high)

            return IntegerCache.cache[i + (-IntegerCache.low)];

        return new Integer(i);

    }

4.4. getInteger 方法

该方法返回 string 参数指定的系统属性值。支持指定默认值（通过第二个参数），若该属性不存在或者不是 int 类型，则返回默认值

    public static Integer getInteger(String nm) {

        return getInteger(nm, null);

    }

    public static Integer getInteger(String nm, int val) {

        Integer result = getInteger(nm, null);

        return (result == null) ? Integer.valueOf(val) : result;

    }

    public static Integer getInteger(String nm, Integer val) {

        String v = null;

        try {

            v = System.getProperty(nm);

        } catch (IllegalArgumentException | NullPointerException e) {

        }

        if (v != null) {

            try {

                return Integer.decode(v);

            } catch (NumberFormatException e) {

            }

        }

        return val;

    }

4.5. hashCode() 方法

Integer 的 hashCode() 值就是它所保存的 int 型值。

/**

     * Returns a hash code for this {@code Integer}.

     *

     * @return  a hash code value for this object, equal to the

     *          primitive {@code int} value represented by this

     *          {@code Integer} object.

     */

    @Override

    public int hashCode() {

        return Integer.hashCode(value);

    }

    /**

     * Returns a hash code for a {@code int} value; compatible with

     * {@code Integer.hashCode()}.

     *

     * @param value the value to hash

     * @since 1.8

     *

     * @return a hash code value for a {@code int} value.

     */

    public static int hashCode(int value) {

        return value;

    }

4.6. equals(Integer) 方法

Integer 的 equals 方法比较的就是保存的 int 型值是否相等。很显然，hashCode 和 equals 方法遵循散列的常规约定。

public boolean equals(Object obj) {

        if (obj instanceof Integer) {

            return value == ((Integer)obj).intValue();

        }

        return false;

    }

5. Integer 的缓存机制

前面学习 Boolean 类保存两个对 true 和 false 值对象的静态引用，使用 valueOf 构造对象时会始终返回其一。Integer 类也同样使用了这种缓存机制。上文中提到了静态工厂方法 valueOf(int) 使用了缓存策略，代码中使用了 IntegerCache 类，那么我们就来看看该类源码，这是 Integer 类的一个内部类，专门用于处理 Integer 缓存机制：

可以看出，该类是私有内部类，开发者不可改变和初始化。该类通过静态代码块在类加载的时候，循环创建 Integer 缓存对象，并创建索引表进行引用，需要时使用索引表快速获取。缓存值范围最小是 -128，最大默认是 127（可以使用虚拟机参数指定，虚拟机默认无该参数）。缓存对象值和所在索引表位置偏移量即是 127。

再回头看看 valueOf(int) 方法：当需要构造的 Integer 对象值在缓存范围之内时，就从索引表查找缓存对象直接返回，否则构造新的对象返回。所以大家在开发中需要构建 Integer 对象时，推荐使用静态工厂方法，少用 new 以节省开支。