①特性

Integer类不能被继承
	
Integer类实现了Comparable接口，所以可以用compareTo进行比较并且Integer对象只能和Integer类型的对象进行比较，不能和其他类型比较
	
Integer继承了Number类，所以该类可以调用longValue、floatValue、doubleValue等系列方法返回对应的类型的值
②方法

compareTo(Integer anotherInteger)
	
equals(Object obj)
	
byteValue()
	
doubleValue()
	
floatValue()
	
intValue()
	
shortValue()
	
longValue()
	
toString()
③示例

 @Test
    public void test1() {
        Integer integer = 12;
        System.out.println(integer.equals(12));
        System.out.println(integer.compareTo(11));
        System.out.println(integer.toString());
        System.out.println(integer.byteValue());
        System.out.println(integer.floatValue());
        System.out.println(integer.intValue());
        System.out.println(integer.longValue());
        System.out.println(integer.shortValue());
    }

 

Integer Cache
IntegerCache源码
Integer 使用Cache源码
瞎搞

IntegerCache源码

java.lang.Integer.IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
        ...
}


Cache会缓存 [low, high-low] 范围内的整数
high默认127 范围 [127, Integer.MAX_VALUE - (-low) -1] , 可由 java.lang.Integer.IntegerCache.high 设置

Integer 使用Cache源码

public final class Integer extends Number implements Comparable<Integer> {
	...
	private final int value;
	...
	public static Integer valueOf(int i) {
		if (i >= IntegerCache.low && i <= IntegerCache.high)
			return IntegerCache.cache[i + (-IntegerCache.low)];
		return new Integer(i);
	}
	...
}


可以看出非new的Integer如果值在[low, high]内, 则复用同一个对象
注意java.lang.Integer#value为final

瞎搞

实现一段任何数字与Integer a = 2相乘为0的功能
/**
 * Integer常量池
 */
@Log4j2
public class ModifyInteger {

    static {
        try {
            modify();
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    private static void modify() throws NoSuchFieldException, IllegalAccessException {
        // 1. 获取 IntegerCache 类
        Class<?> IntegerCache = Integer.class.getDeclaredClasses()[0];

        // 2. 获取 value 字段
        Field integerCacheValue = IntegerCache.getDeclaredField("cache");
        Field integerCacheLow = IntegerCache.getDeclaredField("low");

        // 3. 获取缓存数组
        integerCacheValue.setAccessible(true);
        Integer[] sourceCache = (Integer[]) integerCacheValue.get(Integer.class);

        // 4. 获取缓存最小值
        integerCacheLow.setAccessible(true);
        int low = integerCacheLow.getInt(Integer.class);

        // 5. 将缓存中的 2 修改为 0 (偷梁换柱)
        sourceCache[(low < 0 ? -low : low) + 2] = 0;
    }

    public static void check(Integer n) {
        Random random = new Random(System.currentTimeMillis());
        for (int idx = 0; idx < 10; idx++) {
        	// 14:48:53.775 [main] INFO org.example.codeTest.ModifyInteger - random * 2 = 0
            log.info("random * 2 = {}", random.nextInt(100) * n);
        }
    }
    
    public static void main(String[] args) {
        check(2);
    }
}

Interger在面试中也会经常遇到，关于面试题中遇到的问题在下面注释中有说明
public final class Integer extends Number implements Comparable<Integer>, Constable, ConstantDesc {

    private final int value;        // 真正存储int类型的值
    @java.io.Serial
    @Native
    private static final long serialVersionUID = 1360826667806852920L; // 序列化版本号
    @Native
    public static final int MIN_VALUE = 0x80000000;
    @Native
    public static final int MAX_VALUE = 0x7fffffff;
    @Native
    public static final int SIZE = 32;
    public static final int BYTES = SIZE / Byte.SIZE;
    public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
    static final int[] sizeTable = {9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999, Integer.MAX_VALUE};
    static final 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'
    };
    static final byte[] DigitTens = {
            '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
            '1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
            '2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
            '3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
            '4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
            '5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
            '6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
            '7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
            '8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
            '9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
    };

    static final byte[] DigitOnes = {
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    };

    /**
     * 重点掌握内容，面试题可能会出现
     * 对于-128 ~ 127 以内得数做了缓存，因此-128 ~ 127 内Integer类型得对象是同一个对象
     * 例如：   Integer i1 = 12;
     *         Integer i2 = 12;
     *         System.out.println(i1 == i2);// true
     *
     *         Integer i3 = 128;
     *         Integer i4 = 128;
     *         System.out.println(i3==i4);// false
     * 之所以产生区别就在于-128 ~ 127 内得数做了缓存
     * 拆包：   Integer i5 = 128;
     *         int i6 = 128;
     *         System.out.println(i5 == i6);// true 进行拆包比较所以为true
     * 直接new Integer();比较的是地址，肯定是false
     */
    private static class IntegerCache {
        static final int low = -128; // 缓存最小值-128
        static final int high;// 缓存最大值，后面被赋值为127，在类的初始化过程中静态代码块被执行
        static final Integer[] cache; // 缓存值，缓存的数据都存在这个对象数组中
        static Integer[] archivedCache;
        static {
            int h = 127; // 127以内的值做了缓存，
            String integerCacheHighPropValue = VM.getSavedProperty("java.lang.Integer.IntegerCache.high");// 获取jvm启动参数中的最大值
            if (integerCacheHighPropValue != null) {
                try {
                    h = Math.max(parseInt(integerCacheHighPropValue), 127); // 将手动从jvm启动参数值和127进行比较，得到最大值
                    h = Math.min(h, Integer.MAX_VALUE - (-low) - 1);//
                } catch (NumberFormatException nfe) {}
            }
            high = h;   // high=127，low=-128
            VM.initializeFromArchive(IntegerCache.class);
            int size = (high - low) + 1;
            if (archivedCache == null || size > archivedCache.length) {
                Integer[] c = new Integer[size];
                int j = low;
                for (int i = 0; i < c.length; i++) {
                    c[i] = new Integer(j++);
                }
                archivedCache = c;
            }
            cache = archivedCache;
            assert IntegerCache.high >= 127;
        }
        private IntegerCache() {}
    }

    /**
     * 构造方法
     */
    @Deprecated(since = "9")
    public Integer(int value) {}
    @Deprecated(since = "9")
    public Integer(String s) throws NumberFormatException {}

    public byte byteValue() {}      // 转换成byte类型的值
    public short shortValue() {}    // 转换成short类型的值
    public int intValue() {}        // 得到int值  该方法加了注解：@HotSpotIntrinsicCandidate
    public float floatValue() {}    // 转换成float类型的值
    public long longValue() {}      // 转换成long类型的值
    public double doubleValue() {}  // 转换成double类型的值
    @Override
    public int hashCode() {}        // int类型的hash值就是它本身
    public String toString() {}     // 转换成字符串
    public int compareTo(Integer anotherInteger) {} // Integer比较大小
    public boolean equals(Object obj) {}    // 对象是否是Integer子类，比较其中的int值是否相等


    /**
     * 静态方法
     */
    public static int sum(int a, int b) {}      // 两数之和
    public static int max(int a, int b) {}      // 两数中最大值
    public static int min(int a, int b) {}      // 两数中最小值
    public static Integer getInteger(String nm) {}              // 得到值
    public static Integer getInteger(String nm, int val) {}     // 得到值
    public static Integer getInteger(String nm, Integer val) {} // 得到值
    public static int hashCode(int value) {}            // 得到value代表的整数的hash值
    public static int compare(int x, int y) {}          // 比较两数大小
    public static int compareUnsigned(int x, int y) {}  // 比较无符号两数大小
    public static long toUnsignedLong(int x) {}         // x转换为无符号long类型数据
    /**
     * 字符串转int
     * 如果传入的字符串不是数字，以下方法都可能会 throws NumberFormatException
     */
    public static int parseInt(String s) {}                // 字符串转换成int，默认10进制
    public static int parseInt(String s, int radix) {}     // 字符串转成radix值所代表的进制
    public static int parseInt(CharSequence s, int beginIndex, int endIndex, int radix) {}          //
    public static int parseUnsignedInt(String s) {}       // 解析字符串代表的无符号整数，默认10进制
    public static int parseUnsignedInt(String s,int radix){} // 解析字符串代表的无符号整数，radix代表进制
    public static int parseUnsignedInt(CharSequence s, int beginIndex, int endIndex, int radix) {}  //
    @HotSpotIntrinsicCandidate
    public static Integer valueOf(int i) {}             // 得到i的包装对象
    public static Integer valueOf(String s) {}          // 得到s转换后的包装对象
    public static Integer valueOf(String s, int radix){}// 得到s转换后，经过radix进制转换的包装对象
    public static Integer decode(String nm) {}          // 根据nm表示的意思（各进制例如:0xAF、正负数：-100）转换为Integer包装类型的数据

    /**
     * 转换为各种类型的字符串
     */
    @HotSpotIntrinsicCandidate
    public static String toString(int i) {}                     // 转换为字符串
    public static String toString(int i, int radix) {}          // 按照radix进制转换为字符串
    private static String toStringUTF16(int i, int radix) {}    // 转换为UTF16编码的字符串
    public static String toUnsignedString(int i) {}             // 转换为无符号整数的字符串，默认10进制
    public static String toUnsignedString(int i, int radix) {}  // 按照radix进制转换为无符号整数的字符串
    public static String toHexString(int i) {}                  // 转换为16进制的字符串
    public static String toOctalString(int i) {}                // 转换为10进制的字符串
    public static String toBinaryString(int i) {}               // 转换为2进制的字符串

    /**
     * 不常用方法
     */
    public static int divideUnsigned(int dividend, int divisor) {}      // 得到无符号dividend 除于 divisor
    public static int remainderUnsigned(int dividend, int divisor) {}   // 返回余数
    public static int highestOneBit(int i) {}           // 得到最高位的值（十进制）
    public static int lowestOneBit(int i) {}			// 得到最低位的值
    public static int rotateLeft(int i, int distance) {}// 将i的二进制左移distance位
    public static int rotateRight(int i, int distance){}// 将i的二进制右移distance位
    public static int reverse(int i) {}					// 将
    public static int signum(int i) {}					// 得到i的符号位，负数返回-1，正数返回1，0返回0
    @HotSpotIntrinsicCandidate
    public static int numberOfLeadingZeros(int i) {} // 返回二进制中左边0的个数（int类型数据总共32位所以不会超过64）
    @HotSpotIntrinsicCandidate
    public static int numberOfTrailingZeros(int i) {}// 返回二进制中右边0的个数（int类型数据总共32位所以不会超过64）
    @HotSpotIntrinsicCandidate
    public static int bitCount(int i) {}             // 返回i的二进制表示，1的个数
    @HotSpotIntrinsicCandidate
    public static int reverseBytes(int i) {}		 // 将i二进制表示的位按照字节逆序排序（每8位一个byte像数组一样逆序）

    @Override
    public Optional<Integer> describeConstable() {}

    @Override
    public Integer resolveConstantDesc(MethodHandles.Lookup lookup) {}

    /**
     * 外部使用不到的方法
     */
    static int getChars(int i, int index, byte[] buf) {}
    static int stringSize(int x) {}
    private static String toUnsignedString0(int val, int shift) {}
    private static void formatUnsignedInt(int val, int shift, byte[] buf, int len) {}
    private static void formatUnsignedIntUTF16(int val, int shift, byte[] buf, int len) {}


}

发现做项目的过程中，在数值类型的比较上容易犯错，特别是Integer和Integer的比较，Integer和int的比较。虽然这些都是些基础语法，但稍不留意就容易犯错，在实际开发过程中如果出现这类失误，很容易失之毫厘谬以千里。在这里，总结下这些基础知识点。
java虽然宣称一切都是对象，但原始数据类型是例外。int是整形数字，是java的9个原始数据类型（Primitive Types）（boolean、byte、short、char、int、float、double、long、void）之一。Integer是int对应的包装类，它有一个int类型的字段存储数据，并且提供了基本操作，比如数学运算、int和字符串之间转换等。在java 5中引入了自动装箱和自动拆箱功能（boxing/unboxing），java可以根据上下文，自动进行转换，极大地简化了相关编程。javac自动把装箱转换为Integer.valueOf(),把拆箱替换为Integer.intValue()。
自动装箱实际上算是一种语法糖。什么是语法糖？可以简单理解为java平台为我们自动进行了一些转换，保证不同的写法在运行时等价，他们发生在编译阶段，也就是生产的字节码是一致的。（此句摘自极客时间专栏）
原始数据类型的变量，需要使用并发相关手段才能保证线程安全。如果有线程安全的计算需要，建议考虑使用类似AtomicInteger、AtomicLong这样的线程安全类。
原始数据类型和java泛型并不能配合使用。因为java的泛型某种程度上可以算作伪泛型，它完全是一种编译期的技巧，java编译期会自动将类型转换为对应的特定类型。这就决定了使用泛型，必须保证相应类型可以转换为Object。
废话不多说，直接来demo，这样效果更直接。
public class Test {

	public static void main(String[] args) {
		
		Integer a1 = 6;
		Integer a2 = 6;
		int a11 = 6;
		
		System.out.println(a1 == a2); //true
		System.out.println(a1 == a11); //true
		
		System.out.println("----------------");
		
		Integer a3 = 128;
		Integer a4 = 128;
		int a33 = 128;
		
		System.out.println(a3 == a4); //false
		//Integer会自动拆箱为int，所以为true
		System.out.println(a3 == a33); //true
		System.out.println(a3.equals(a4)); //true
		
		System.out.println("----------------");
		
		Integer a5 = new Integer(6);
		Integer a6 = new Integer(6);
		
		System.out.println(a5 == a6); //false
		System.out.println(a5.equals(a6)); //true

	}

需要明确的一点是，包装型（Integer）和基本型（int）比较会自动拆箱（jdk1.5以上）。
在这里很多人比较容易迷惑的是如下情况：
		Integer a1 = 6;
		Integer a2 = 6;
		System.out.println(a1 == a2); //true
		
		Integer a3 = 128;
		Integer a4 = 128;
		System.out.println(a3 == a4); //false

如果研究过jdk源码，你就会发现Integer a3 = 128;在java编译时会被翻译成 Integer a3 = Integer.valueOf(128); 我们再来看看valueOf()的源码就更清晰了。
public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

由以上源码就会发现，对于-128到127之间的数，会进行缓存，Integer a1 = 6时，会将6进行缓存，下次再写Integer a2 = 6;时，就会直接从缓存中取，也就不用new一个对象了，所以a1和a2比较时就为true。但a3和a4是超过范围，会new一个对象，==是进行地址和值比较，是比较两个对象在JVM中的地址，这时a3和a4虽然值相同但地址是不一样的，所以比较就为false了。
通过上面的分析可知：

两个都不是new出来的Integer，且数值在-128~127之间，用==比较时，基本值相等时为true，否则为false；
两个都是new出来的Integer，为false
int和Integer比较，数值相同，用==比较时为true。（因为Integer会自动拆箱为int去比较）


所有包装类对象之间值的比较，建议使用equals方法比较。

==判断对象是否同一个。
Integer var = ?在缓存区间的赋值，会复用已有对象，因此这个区间内的Integer使用==进行判断可通过，但是区间之外的所有数据，则会在堆上新产生，不会通过。
因此如果用== 来比较数值，很可能在小的测试数据中通过，而到了生产环境才出问题。
为了节省内容，对与下列包装对象的两个实例，当他们的基本值相同时，用==判断会为true：
 Boolean  
 Byte  
 Character, \u0000 - \u007f(7f是十进制的127)  
 Integer, -128 — 127  

我们也可以看看其它包装型的缓存情况：
Boolean：(全部缓存)
Byte：(全部缓存)

Character(缓存范围'\u0000'到'\u007F')
Short(-128 — 127缓存)
Long(-128 — 127缓存)

Float(没有缓存)
Doulbe(没有缓存)

如果要比较两个Integer对象的值（均为new的对象），可以通过.intValue()进行转换后来比较，如下：
		Integer a3 = 128;
		Integer a4 = 128;
		System.out.println(a3.intValue() == a4.intValue());

也可以使用equal()来进行比较，如下：
		Integer a3 = 128;
		Integer a4 = 128;
		System.out.println(a3.equals(a4)); //true