基于 JDK1.8 的 Java 源码详解 Integer

介绍

本文将会详细讲解 JDK1.8 版本中的 Integer 类的源码实现。Integer 类是 Java 中表示整数类型的包装类，在日常开发中非常常用。通过对其源码的分析和理解，可以帮助程序员更好的理解 Java 中整数类型的实现方式，有助于优化代码和解决实际问题。

Integer 类的源码结构

首先，我们来看看 Integer 类源码中的主要结构。Integer 类的源码比较简单，主要分为以下几个部分：

常量

Integer 类中定义了以下常量：

public static final int MAX_VALUE = 0x7fffffff;
public static final int MIN_VALUE = 0x80000000;
public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

其中，MAX_VALUE 和 MIN_VALUE 表示 int 类型的最大值和最小值，TYPE 表示 Integer 类对应的基本类型为 int。

成员变量

实际上，Integer 类只有一个成员变量：

private final int value;

其中，value 表示 Integer 类型的数值。

构造方法

Integer 类中定义了以下构造方法：

public Integer(int value) {
    this.value = value;
}

public Integer(String s) throws NumberFormatException {
    this.value = parseInt(s, 10);
}

其中，第一个构造方法接受一个 int 类型参数，用于构造一个 Integer 对象；第二个构造方法接受一个字符串参数，用于将字符串转换为 Integer 对象。如果字符串不能转换为有效的整数，则会抛出 NumberFormatException 异常。

静态方法

Integer 类中还定义了很多静态方法，这里只列举部分常用方法：

public static int parseInt(String s, int radix) throws NumberFormatException {
    // ...
}

public static int parseInt(String s) throws NumberFormatException {
    return parseInt(s, 10);
}

public static String toString(int i, int radix) {
    // ...
}

public static String toString(int i) {
    return toString(i, 10);
}

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

public static Integer valueOf(String s, int radix) throws NumberFormatException {
    return new Integer(parseInt(s, radix));
}

public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(s, 10);
}

其中，parseInt、toString 和 valueOf 这三个方法非常常用，分别用于解析整数、将整数转换为字符串以及将 int 类型转换为 Integer 类型。

实例方法

Integer 类还定义了以下实例方法：

public byte byteValue() {
    return (byte)value;
}

public short shortValue() {
    return (short)value;
}

public int intValue() {
    return value;
}

public long longValue() {
    return (long)value;
}

public float floatValue() {
    return (float)value;
}

public double doubleValue() {
    return (double)value;
}

public static Integer decode(String nm) throws NumberFormatException {
    // ...
}

public int compareTo(Integer anotherInteger) {
    return compare(this.value, anotherInteger.value);
}

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

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

public static Integer sum(int a, int b) {
    return valueOf(a + b);
}

public static Integer divideUnsigned(int dividend, int divisor) {
    return valueOf((dividend >>> 1) / divisor);
}

public static int remainderUnsigned(int dividend, int divisor) {
    return (dividend >>> 1) % divisor;
}

其中，byteValue、shortValue、intValue、longValue、floatValue 和 doubleValue 分别用于将 Integer 类型转换为 byte、short、int、long、float 和 double 类型；compareTo 方法实现了 Integer 类型的比较操作；equals 方法用于判断两个 Integer 对象是否相等；sum 方法用于计算两个 int 类型相加的结果；divideUnsigned 和 remainderUnsigned 方法分别实现了无符号整数的除法和求余操作。

示例

示例一：将整数转换为指定进制的字符串

public static String integerToBinaryString(int i) {
    return toUnsignedString0(i, 1);
}

public static String toUnsignedString0(int val, int shift) {
    // ...
}

public static String intToHexString(int i) {
    return toUnsignedString0(i, 4);
}

以上两个方法分别用于将一个 int 类型的整数转换为二进制字符串和 16 进制字符串。例如：

int num = 255;
String binary = Integer.integerToBinaryString(num);
String hex = Integer.intToHexString(num);
System.out.println("二进制：" + binary); // 输出：二进制：11111111
System.out.println("十六进制：" + hex); // 输出：十六进制：ff

示例二：无符号整数的除法和求余

int dividend = -3;
int divisor = 2;

// 计算无符号整数的商
Integer quotient = Integer.divideUnsigned(dividend, divisor);
System.out.println("商：" + quotient); // 输出：商：2147483647

// 计算无符号整数的余数
int remainder = Integer.remainderUnsigned(dividend, divisor);
System.out.println("余数：" + remainder); // 输出：余数：1

以上代码中，dividend 为负整数，但是在无符号除法中，实际上会将其视为一个很大的正整数（因为 Java 中没有无符号整数类型），所以计算结果为 2147483647。而余数的计算结果为 1。