Integer源码阅读

最新推荐文章于 2021-11-27 20:22:05 发布
最新推荐文章于 2021-11-27 20:22:05 发布
阅读量161 收藏
点赞数
分类专栏： jdk源码 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43663493/article/details/118942665
版权

对于java自动装箱与自动拆箱我目前只停留在知道使用的层面上，为了能够进一步的对其进行深入的研究，下面从源码开始对其进行分析。

分析类

最首先的当然是从类的继承实现情况开始。

public final class Integer extends Number implements Comparable<Integer> {...}

对与这个Integer类，它实现了Comparable接口，继承了Number.

  1. Comparatable : 强行对实现它的类的每个实例进行自然排序,该接口的唯一方法compareTo方法被称为自然比较方法
  2. Number类:继承了Serializable接口，内有实现对数操作的一些方法。
  3. 该类被final修饰，不可被继承
  4. public关键字修饰，这个很好理解，这个类定义出来是被所有的类的使用的，包括Java的使用者定义的类来使用的。所以一定是public的。
分析属性
/**
 * The value of the {@code Integer}.
 *
 * @serial
 */
private final int value;
  • Integer用于存储数据的属性，类型为整形
常量分析
//A constant holding the minimum value an int can have, -231.
@Native public static final int   MIN_VALUE = 0x80000000;
//A constant holding the maximum value an int can have, 231-1.
@Native public static final int   MAX_VALUE = 0x7fffffff;
  1. 这两个属性都是一个整形变量，用来保存最大值与最小值
  2. 注解修饰成员变量，表示这个变量可以被本地代码引用
  3. final修饰 不可被修改
public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
  • 获取int类型的虚拟机类对象
final static char[] digits = {
    '0' , '1' , '2' , '3' , '4' , '5' ,
    '6' , '7' , '8' , '9' , 'a' , 'b' ,
    'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
    'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
    'o' , 'p' , 'q' , 'r' , 's' , 't' ,
    'u' , 'v' , 'w' , 'x' , 'y' , 'z'
};
  • 数字为字符串类型的所有可能表现形式
方法分析
public static String toString(int i, int radix) {
    if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
        radix = 10;

     /* 如果是10进制，直接转字符串即可 */
    /* Use the faster version */
    if (radix == 10) {
        return toString(i);
    }

    // 存放转换进制后的字符数组
    char buf[] = new char[33];
    boolean negative = (i < 0);
    // 将指针指向buf数组最后一位，以便后边存放字符
    int charPos = 32;

    if (!negative) {
        i = -i;
    }

    /* 使用短除法来转换进制 */
    while (i <= -radix) {
        buf[charPos--] = digits[-(i % radix)];
        i = i / radix;
    }
    buf[charPos] = digits[-i];

    if (negative) {
        buf[--charPos] = '-';
    }

    return new String(buf, charPos, (33 - charPos));
}
  • 返回由第二个参数指定的基数中的第一个参数的字符串表示形式，例如：Integer.toString(3,2)，得到3的二进制表示形式。
public static String toUnsignedString(int i, int radix) {
    return Long.toUnsignedString(toUnsignedLong(i), radix);
}
  • 返回由第二个参数指定的基数中的第一个参数的字符串表示形式
public static String toString(int i) {
    if (i == Integer.MIN_VALUE)
        return "-2147483648";
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    char[] buf = new char[size];
    getChars(i, size, buf);
    return new String(buf, true);
}
  • 返回一个代表指定整形类型的String类型对象
public static String toUnsignedString(int i) {
    return Long.toString(toUnsignedLong(i));
}
  • 将参数的字符串表示形式返回为无符号十进制值。

接下来，是这个封装类的最==重要==的几个方法：

public static int parseInt(String s, int radix)
                throws NumberFormatException
    {
        /*
         * WARNING: This method may be invoked early during VM initialization
         * before IntegerCache is initialized. Care must be taken to not use
         * the valueOf method.
         */

        if (s == null) {
            throw new NumberFormatException("null");
        }

        if (radix < Character.MIN_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " less than Character.MIN_RADIX");
        }

        if (radix > Character.MAX_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " greater than Character.MAX_RADIX");
        }

        int result = 0;
        boolean negative = false;
        int i = 0, len = s.length();
        int limit = -Integer.MAX_VALUE;
        int multmin;
        int digit;

        if (len > 0) {
            char firstChar = s.charAt(0);
            if (firstChar < '0') { // Possible leading "+" or "-"
                if (firstChar == '-') {
                    negative = true;
                    limit = Integer.MIN_VALUE;
                } else if (firstChar != '+')
                    throw NumberFormatException.forInputString(s);

                if (len == 1) // Cannot have lone "+" or "-"
                    throw NumberFormatException.forInputString(s);
                i++;
            }
            multmin = limit / radix;
            while (i < len) {
                // Accumulating negatively avoids surprises near MAX_VALUE
                digit = Character.digit(s.charAt(i++),radix);
                if (digit < 0) {
                    throw NumberFormatException.forInputString(s);
                }
                if (result < multmin) {
                    throw NumberFormatException.forInputString(s);
                }
                result *= radix;
                if (result < limit + digit) {
                    throw NumberFormatException.forInputString(s);
                }
                result -= digit;
            }
        } else {
            throw NumberFormatException.forInputString(s);
        }
        return negative ? result : -result;
    }
例子：
       parseInt("0", 10) returns 0
       parseInt("473", 10) returns 473
       parseInt("+42", 10) returns 42
       parseInt("-0", 10) returns 0
       parseInt("-FF", 16) returns -255
       parseInt("1100110", 2) returns 102
       parseInt("2147483647", 10) returns 2147483647
       parseInt("-2147483648", 10) returns -2147483648
       parseInt("2147483648", 10) throws a NumberFormatException
       parseInt("99", 8) throws a NumberFormatException
       parseInt("Kona", 10) throws a NumberFormatException
       parseInt("Kona", 27) returns 411787
  • 将字符串参数解析为第二个参数指定的基数中的有符号整数。
    public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }
  • 这个方法一看方法体就知道了，不用多说
public static int parseUnsignedInt(String s, int radix)
            throws NumberFormatException {
    if (s == null)  {
        throw new NumberFormatException("null");
    }

    int len = s.length();
    if (len > 0) {
        char firstChar = s.charAt(0);
        if (firstChar == '-') {
            throw new
                NumberFormatException(String.format("Illegal leading minus sign " +
                                                   "on unsigned string %s.", s));
        } else {
            if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
                (radix == 10 && len <= 9) ) { // Integer.MAX_VALUE in base 10 is 10 digits
                return parseInt(s, radix);
            } else {
                long ell = Long.parseLong(s, radix);
                if ((ell & 0xffff_ffff_0000_0000L) == 0) {
                    return (int) ell;
                } else {
                    throw new
                        NumberFormatException(String.format("String value %s exceeds " +
                                                           "range of unsigned int.", s));
                }
            }
        }
    } else {
        throw NumberFormatException.forInputString(s);
    }
}
  • 将字符串参数解析为第二个参数指定的基数中的无符号整数。
    public static int parseUnsignedInt(String s) throws NumberFormatException {
        return parseUnsignedInt(s, 10);
    }
  • 不多说，看方法体
    public static Integer valueOf(String s, int radix) throws NumberFormatException {
        return Integer.valueOf(parseInt(s,radix));
    }
  • 返回一个 Integer指定的 int值的 Integer实例。
public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, 10));
}
  • 看方法体
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
  • 返回一个 Integer指定的 int值的 Integer实例
  • 这个方法需要特别注意：IntegerCache为Integer类的缓存类，默认缓存了-128~127的Integer值，如遇到[-128,127]范围的值需要转换为Integer时会直接从IntegerCache中获取
/**
 * 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;
}
  • 构造方法
public Integer(String s) throws NumberFormatException {
    this.value = parseInt(s, 10);
}
  • 构造一个新分配的Integer对象，该对象表示由String参数表示的int值。字符串转换为int值的方式与parseInt方法用于基数10的方式完全相同。
public String toString() {
    return toString(value);
}
  • 重写Object类的toString()方法
@Override
public int hashCode() {
    return Integer.hashCode(value);
}
public static int hashCode(int value) {
    return value;
}
  • 重写hashCode()方法
public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}
  • 重写equals()方法
/**
 * Compares two {@code Integer} objects numerically.
 *
 * @param   anotherInteger   the {@code Integer} to be compared.
 * @return  the value {@code 0} if this {@code Integer} is
 *          equal to the argument {@code Integer}; a value less than
 *          {@code 0} if this {@code Integer} is numerically less
 *          than the argument {@code Integer}; and a value greater
 *          than {@code 0} if this {@code Integer} is numerically
 *           greater than the argument {@code Integer} (signed
 *           comparison).
 * @since   1.2
 */
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) ? -1 : ((x == y) ? 0 : 1);
}
  • 实现接口方法
 /**
     * 返回指定int值的符号函数（所谓的符号函数就是确定输入值的符号【正数|负数|0】）
     * 如果指定值为负数，则返回值为-1；如果指定值为0，则返回值为0；如果指定值为正数，则返回值为1
     *
     * @param i 要计算其符号的值
     * @return 返回指定int值的符号，如果是负数返回-1，0返回0，正数返回1
     */
    public static int signum(int i) {
        // 如果是正数，则可以通过(-i >>> 31)确定符号，即获取最高位的符号。因为(i >> 31)会为0。
        // 如果是负数，则可以通过(i >> 31)确定符号，即获取最高位的符号。因为(-i >>> 31)会为0。
        return (i >> 31) | (-i >>> 31);
    }

  • 返回指定int值的符号函数

  • 分析：

    • 
/*
(i >> 31) | (-i >>> 31)
第一种情况：i是正数，则返回1。例如i=96所对应的二进制是0000 0000 0000 0000 0000 0000 0110 0000
        i=0000 0000 0000 0000 0000 0000 0110 0000
    i>>31=0000 0000 0000 0000 0000 0000 0000 0000
       -i=1111 1111 1111 1111 1111 1111 1010 0000
  -i>>>31=0000 0000 0000 0000 0000 0000 0000 0001
(i >> 31) | (-i >>> 31)
          0000 0000 0000 0000 0000 0000 0000 0000
         |
          0000 0000 0000 0000 0000 0000 0000 0001
         =0000 0000 0000 0000 0000 0000 0000 0001
第二种情况：i是0，则返回0。
第三种情况：i是负数，则返回-1。例如i=-96所对应的二进制是1111 1111 1111 1111 1111 1111 1010 0000
        i=1111 1111 1111 1111 1111 1111 1010 0000
    i>>31=1111 1111 1111 1111 1111 1111 1111 1111
       -i=0000 0000 0000 0000 0000 0000 0110 0000
  -i>>>31=0000 0000 0000 0000 0000 0000 0000 0000
(i >> 31) | (-i >>> 31)
          1111 1111 1111 1111 1111 1111 1111 1111
         |
          0000 0000 0000 0000 0000 0000 0000 0000
         =1111 1111 1111 1111 1111 1111 1111 1111
 */


public static int sum(int a, int b) {
    return a + b;
}
  • 返回两数之和
public static int max(int a, int b) {
    return Math.max(a, b);
}
  • 返回最大值
public static int min(int a, int b) {
    return Math.min(a, b);
}
  • 返回最小值
IntegerCache类
/**
 * Cache to support the object identity semantics of autoboxing for values between
 * -128 and 127 (inclusive) as required by JLS.
 *
 * The cache is initialized on first usage.  The size of the cache
 * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 * During VM initialization, java.lang.Integer.IntegerCache.high property
 * may be set and saved in the private system properties in the
 * sun.misc.VM class.
 */

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

面试：

/**
 * Integer的值在-128到127时（包括-128和127），Integer对象是在IntegerCache.cache产生，会复用已有对象，
 * 也就是说，这个区间的Integer可以直接用等号进行判断。
 * Integer的值在-128到127之外时，Integer对象在堆上产生，不会复用已有对象，用等号会返回false。
 * 建议老老实实用equals()方法来比较Integer对象。
 * @param value
 */

案例1：

        Integer a = 127;
        Integer b = 127;
        Integer c = 128;
        Integer d = 128;
        System.out.println(a==b);
        System.out.println(c==d);

        Integer e = -128;
        Integer f = -128;
        Integer g = -129;
        Integer h = -129;
        System.out.println(e==f);
        System.out.println(g==h);

输出：

true
false
true
false

案例2：

public class EqualsMethod
{
    public static void main(String[] args)
    {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.print(n1 == n2);
        System.out.print(",");
        System.out.println(n1 != n2);
    }
}

选择以上程序段的输出结果为：
A:false，false
B:false，true
C:true，false
D:true，true

选择B，这里直接是new出来的对象不涉及缓存，n1,n2是不同的对象。

结论：

  1. Integer的值在-128到127时，Integer对象是在IntegerCache.cache产生，会复用已有对象，也就是说，这个区间的Integer可以直接用等号进行判断。
  2. Integer的值在-128到127之外时，Integer对象在堆上产生，不会复用已有对象，用等号会返回false
柒间
关注
专栏目录
Integer类源码阅读
HOOHV的博客
03-25 313
Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。此外，该类提供了多个方法，能在int类型和 String类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。 1.父类 接口 Integer的父类是Number类，Number类有一个java.io.Serializable序列化接口。 成员变量...
1.9 JDK源码阅读之Integer
码畜
08-08 716
 最大最小范围 可以代表number的char[]    toString parseInt   Integer把-128到127（可调）的整数都提前实例化了。 这就解释了上面那道面试题的答案，原来你不管创建多少个这个范围内的Integer用ValueOf出来的都是同一个对象。但是为什么JDK要这么多此一举呢？ 我们仔细想想， 淘宝的商品大多数都是100以内...
JAVA源码阅读——–Integer类
趁着这大好时光，多看看。
01-19 490
JAVA源码阅读——–Integer类 类定义 Integer类被final关键词修饰，不可被继承 Integer类继承Number类并实现其方法，可返回其他基本类型数据，例如longValue()返回long类型数据 Integer类实现了comparable接口，可以利用CompareTo方法与其他Integer对象比较 私有属性 用于存储Integer的实际值 pri
JDK源码阅读之Integer
带翅膀的猫的博客
08-20 3464
我们在学习对象的自动装箱和自动拆箱时首次接触的就是Integer类。同时我们知道如果新建小数字对象其实是同一个对象，那么这之中的奥秘是什么呢？现在我们从源码的角度剖析一下吧！
Integer源码解析
weixin_42146366的博客
07-29 566
一、前言     Integer类是我们经常用到的一个基础类，学习其底层结构有助于我们在项目中更加得心应手的使用他，并且能够有效避免Integer所遇到的坑。这篇博客主要是介绍Integer经常使用的几个方法其源码是怎么做的，而且针对Integer的一些变量进行解释，这会有助于我们读懂Integer的源码。 二、源码解析 继承了哪些类     由上图可知Integer继承了Number抽象类和实现了Comparable接口。
Integer IntegerCache源码阅读
08-28
在源码中，`IntegerCache` 类起着关键作用。 `IntegerCache` 是一个内部私有静态类，它维护了一个缓存数组，用于存储-128到127之间的 `Integer` 对象。这个范围的选择是因为这些数值在Java虚拟机（JVM）中会被自动...
Integer源代码
weixin_39708473的博客
12-27 344
java.lang.Integer源代码
javainteger源码-BinarySearch:此存储库包含Java的源代码，该源代码用于使用二进制搜索算法在子集中搜索整数的算法
05-20
该存储库包含Java的源代码，该源代码用于使用二进制搜索算法在数组中搜索整数的算法。 可以很容易地转换代码以在子集中查找特定项，现在，它在子集0到n（基本上是整个数组）中寻找该项。 如果数组未排序，则在使用二...
Java源码解析Integer方法解读
08-31
在Java编程语言中，Integer类是int类型的一个包装类，提供了许多方便的静态方法和实例方法来处理整型数据。本文将重点解析Integer类中的一些关键方法，包括toString、toUnsignedString以及highestOneBit。 首先，...
基于jdk1.8的Java源码详解 Integer
08-25
基于jdk1.8的Java源码详解Integer Java中的Integer类是int类型的Warpper类，是面向对象的即OOP的对象类型。它继承了Number类，可以将Integer转换成int、double、float、long、byte和short类型的数据。同时，Integer...
Integer源码浅析IntegerCache
tobylxy的专栏
08-24 150
一、引例，看如下代码 [code="java"] int a = 100, b = 100; System.out.println(a == b); // true，缓存了 Integer c = 1000, d = 1000; System.out.println(c == d); // false，没有缓存，要new Integer e = -128, f = ...
从源码分析Integer缓存机制IntegerCache和自动拆箱装箱解析
1+1=王的博客
11-27 4831
Integer的自动拆箱装箱解析IntegerCache自动拆箱与装箱 IntegerCache 自动拆箱与装箱
java 数据封装_java封装数据类型——Integer
weixin_29817227的博客
02-12 556
今天来学习整型 int 的封装数据类型，Integer。1. 定义首先来看看定义。可以看到，Integer 继承 Number 抽象类，实现了 Comparable 接口。Number 类是常用数字类型类的公共父类，它规定了其子类(通常就是数字类)必须提供将其值转换成 int、long、float、double、byte、short 类型数据的能力。实现 Comparable 接口自然是为了比较大...
Java 基本数据类型包装类
Stitch__的博客
08-28 1040
  处理场景：通过文本框获取用户输入的数字数据，可是得到的都是字符串，如果想要对这些字符串的数字进行运算，必须妖精字符串转化成数字， 在Java中提供了相应的解决的对象 基本数据类型包装类：Java将基本数据类型值封装成了对象。封装成对象有什么好处？——这样可以提供更多操作基本数值的功能 一般我们对数值的基本操作就是通过运算符来进行运算但是如果我们想要获得一个数值的二进制，这个就是对数值的...
java.lang.Integer常用方法
书香水墨
01-31 5699
+构造函数 Integer(int value) 通过指定的int值构成一个Integer对象。 Integer(String s) 通过指定的String值构成一个Integer对象。。 +方法 int intValue() 将此对象转化为int。 long longValue() 将此对象转化为long。 byte byteValue() 将此对象转化为byte。 sho...
java-Integer 类
weixin_30519071的博客
07-19 105
Class Integer java.lang.Object java.lang.Number java.lang.Integer All Implemented Interfaces:Serializable ， Comparable < Integer > public final class Integer ...
Java的Integer类
qiqi_miao的博客
09-11 1951
1.用途 包装一个对象中的原始类型int的值，封装基本数据类型 int ，将字符串转成基本数据类型 int。 2.特点 类型为Integer的对象包含一个单一字段，其类型为int 。此外，该类还提供了一些将int转换为String和String转换为int ，以及在处理int时有用的其他常量和方法。有构造方法。 3.基本字段 （1）MIN-VALUE public static final int...
java的Integer类源码详解
悦分享
09-03 2550
java的Integer类源码详解 类的定义 public final class Integer extends Number implements Comparable<Integer> { @Native public static final int MIN_VALUE = 0x80000000; @Native public static fina...
Integer.parseInt源码
最新发布
05-30
`Integer.parseInt()` 函数的具体实现如下： ```java public static int parseInt(String s) throws NumberFormatException { return parseInt(s,10); } public static int parseInt(String s, int radix) ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值