Interger：整数类型
 
 １、属性。
 
 static int MAX_VALUE：返回最大的整型数； 
 static int MIN_VALUE：返回最小的整型数； 
 static Class TYPE ：返回当前类型。
 
 例子： 
 System.out.println(“Integer.MAX_VALUE: ” + Integer.MAX_VALUE ); 
 结果为：Integer.MAX_VALUE: 2147483647
 
 ２、构造函数。
 
 Integer(int value) ：通过一个int的类型构造对象； 
 Integer(String s) ：通过一个String的类型构造对象；
 
 例子： 
 Integer i = new Integer(“1234”); 
 生成了一个值为1234的Integer对象。
 
 ３、方法。 
 说明： 
 1. 所有方法均为public； 
 2. 书写格式：［修饰符］　<返回类型> <方法名（［参数列表］）> 
 如： 
 static int parseInt(String s) 表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。
 
byteValue()：取得用byte类型表示的整数；
int compareTo(Integer anotherInteger) ：比较两个整数。相等时返回０；小于时返回负数；大于时返回正数。
 
 例子：
 
 Integer i = new Integer(1234); 
 System.out.println(“i.compareTo: ” + i.compareTo(new Integer(123)) ); 
 结果为：i.compareTo: 1
 
int compareTo(Object o) ：将该整数与其他类进行比较。如果o也为Integer类，进行方法2 的操作；否则，抛出ClassCastException异常。
static Integer decode(String nm) ：将字符串转换为整数。
double doubleValue() ：取得该整数的双精度表示。
boolean equals(Object obj) ：比较两个对象。
float floatValue() ：取得该整数的浮点数表示。
static Integer getInteger(String nm) ：根据指定名确定系统特征值。
static Integer getInteger(String nm, int val) ：上面的重载。
static Integer getInteger(String nm, Integer val) ：上面的重载。
int hashCode() ：返回该整数类型的哈希表码。
int intValue() ： 返回该整型数所表示的整数。
long longValue() ：返回该整型数所表示的长整数。
static int parseInt(String s) ：将字符串转换成整数。s必须是时进制数组成，否则抛出NumberFormatException异常。
static int parseInt(String s, int radix) ：以radix为基数radix返回s的十进制数。所谓的基数，就是“几进制”。
 
 例子：
 
 String s1 = new String(“1010”); 
 System.out.println(“Integer.parseInt(String s, int radix): ” + Integer.parseInt(s1,2) ); 
 结果为：Integer.parseInt(String s, int radix): 10
 
short shortValue() ：返回该整型数所表示的短整数。
static String toBinaryString(int i) ：将整数转为二进制数的字符串。
static String toHexString(int i) ：将整数转为十六进制数的字符串。
static String toOctalString(int i) ：将整数转为八进制数的字符串。
String toString() ：将该整数类型转换为字符串。
static String toString(int i) ：将该整数类型转换为字符串。不同的是，此为类方法。
static String toString(int i, int radix) ：将整数i以基数radix的形式转换成字符串。
 
 例子： 
 int i1 = 54321; 
 System.out.println(“Integer.toString(int i, int radix): ” + Integer.toString(i1,16) ); 
 结果为：Integer.toString(int i, int radix): d431
 
static Integer valueOf(String s) ：将字符串转换成整数类型。
 
 
static Integer valueOf(String s, int radix) ：将字符串以基数radix的要求转换成整数类型。
 

  
 
lowestOneBit(int i) 
          返回具有至多单个 1 位的 int 值，在指定的 int 值中最低位（最右边）的 1 位的位置
highestOneBit(int i) 
          返回具有至多单个 1 位的 int 值，在指定的 int 值中最高位（最左边）的 1 位的位置。
numberOfLeadingZeros(int i) 
          在指定 int 值的二进制补码表示形式中最高位（最左边）的 1 位之前，返回零位的数量。
numberOfTrailingZeros(int i) 
          返回指定的 int 值的二进制补码表示形式中最低（“最右”）的为 1 的位后面的零位个数。
 
 
 package com.herman.test;  
   
 public class IntegerTest {  
     public static void main(String[] args) {  
         System.out.println("Integer中的常量****************************");  
         System.out.println("Integer的最大取值：\t"+Integer.MAX_VALUE);  
         System.out.println("Integer的最小取值：\t"+Integer.MIN_VALUE);  
         System.out.println("Integer的最大位数：(以二进制补码形式表示 int 值的位数。)\t"+Integer.SIZE);  
         System.out.println("Integer的类型的：\t"+Integer.TYPE);  
           
         System.out.println();  
         System.out.println("Integer中方法的使用**************************");  
         int i=1000;  
         System.out.println("1000的二进制表示：\t"+Integer.toBinaryString(i));  
         System.out.println("1000的二进制串中“1”的总数量：\t"+Integer.bitCount(i));  
         /** 
          * numberOfLeadingZeros计算方法为：32(Integer.SIZE)-Integer.toBinaryString(1000).length() 
          */  
         System.out.println("1000的二进制串中从最左边算起连续的“0”的总数量：\t"+Integer.numberOfLeadingZeros(i));  
         System.out.println("1000的二进制串中从最右边算起连续的“0”的总数量：\t"+Integer.numberOfTrailingZeros(i));  
         /** 
          * Integer decode(String nm)  
          * 给定一个10进制，8进制，16进制中任何一种进制的字符串， 
          * 该方法可以将传入的字符串转化为10进制数字的Integer类型并返回。 
          */  
         System.out.println("8的八进制为010，转换为10进制：\t"+Integer.decode("010"));  
         System.out.println("10的十进制为10，转换为10进制：\t"+Integer.decode("10"));  
         System.out.println("16的十六进制 为0X10，转换为10进制：\t"+Integer.decode("0X10"));  
         System.out.println("1000反转整数二进制补码的位顺序：\t"+Integer.reverse(i));  
         System.out.println("1000反转整数字节的顺序：\t"+Integer.reverseBytes(i));  
         /** 
          * 获取整数符号，为负返回-1，正返回1，零返回0 
          */  
         System.out.println("1000获取整数符号为：\t"+Integer.signum(i));  
         System.out.println("创建1000的Integer对象：\t"+Integer.valueOf(i));  
         System.out.println("Integer.valueOf对象的使用(1000的radix进制数)：\t"+Integer.valueOf("1000", 10));  
         /** 
          * Integer.getInteger(String)的功能是根据指定的名称得到系统属性的整数值。 
          * 第一个参数将被认为是系统属性的名称。 
          * 系统属性可以通过 System.getProperty(java.lang.String)方法访问得到。 
          * 属性值字符串将被解释成一个整数，并且以表示这个值的Integer对象形式返回。 
          * 可能出现的数字格式的详细说明可以在 getProperty 的定义说明里找到。 
          */  
         System.out.println("getInteger取的是系统配置:\t"+Integer.getInteger("sun.arch.data.model"));  
         System.out.println("getInteger取的是系统配置:\t"+Integer.getInteger("java.version"));  
         System.out.println("getInteger取的是系统配置:\t"+Integer.getInteger("java.lang.String"));  
         /** 
          * 如果存在sun.arch.data.model系统属性的整数值，则返回该整数值 
          * 如果不存在该整数值，则返回参数（val）2的值 
          */  
         System.out.println("getInteger取的是系统配置:\t"+Integer.getInteger("sun.arch.data.model",16));  
         //返回具有单个1位的int值，在指定值中最高位的1位的位置，否则如果指定本身等于0，则返回0  
         System.out.println("返回最高位为1, 其它位为0的数(右边):\t"+Integer.highestOneBit(i));  
         System.out.println("返回最高位为1, 其它位为0的数(左边):\t"+Integer.lowestOneBit(i));  
         System.out.println("将i左移distance,如果distance为负，则右移-distance:\t"+Integer.rotateLeft(i, 2));  
         System.out.println("将i无符号右移distance,如果distance为负，则左移-distance。负的肯定会移成正的:\t"+Integer.rotateRight(i, 2));  
           
         System.out.println();  
         System.out.println("Integer对象的方法使用******************************");  
         Integer obj=new Integer(1000);  
         System.out.println("1000转换为byte类型的数为：\t"+obj.byteValue());  
         System.out.println("Integer1000和Integer2000大小比较：\t"+obj.compareTo(new Integer(2000)));  
         System.out.println("Integer2000和Integer1000大小比较：\t"+new Integer(2000).compareTo(obj));  
         System.out.println("Integer1000转换为double类型的数为：\t"+obj.doubleValue());  
         System.out.println("Integer1000和Integer2000大小比较：\t"+obj.equals(new Integer(2000)));  
         System.out.println("Integer2000和Integer1000大小比较：\t"+new Integer(2000).equals(obj));  
         System.out.println("Integer2000和Integer1000大小比较：\t"+new Integer(2000).equals(new Integer(2000)));  
         System.out.println("Integer1000的哈希码：\t"+obj.hashCode());  
         System.out.println("Integer1000的int值：\t"+obj.intValue());  
         System.out.println("Integer1000的long值：\t"+obj.longValue());  
         System.out.println("Integer1000的short值：\t"+obj.shortValue());  
         System.out.println("将字符串1000解析为int类型的数：\t"+Integer.parseInt("1000"));  
         /** 
          * Integer.parseInt("1000", 2) 
          * 返回第一个参数的(字符串)的2进制(参数2为转换的进制) 
          */  
         System.out.println("返回1000的2进制"+Integer.parseInt("1000", 2));  
         /** 
          * 进制转换 
          */  
         System.out.println("1000十进制转成二进制"+Integer.toBinaryString(i));  
         System.out.println("1000十进制转八进制：\t"+Integer.toOctalString(i));  
         System.out.println("1000十进制转十六进制：\t"+Integer.toHexString(i));  
         System.out.println("十六进制转成十进制:\t"+Integer.valueOf("FFFF",16).toString());  
         System.out.println("十六进制转成二进制:\t"+Integer.toBinaryString(Integer.valueOf("FFFF",16)));  
         System.out.println("十六进制转成八进制:\t"+Integer.toOctalString(Integer.valueOf("FFFF",16)));  
           
         System.out.println("八进制转成十进制:\t"+Integer.valueOf("576",8).toString());  
         System.out.println("八进制转成二进制:\t"+Integer.toBinaryString(Integer.valueOf("23",8)));  
         System.out.println("八进制转成十六进制:\t"+Integer.toHexString(Integer.valueOf("23",8)));  
           
         System.out.println("二进制转十进制:\t"+Integer.valueOf("0101",2).toString());  
         System.out.println("二进制转八进制:\t"+Integer.toOctalString(Integer.parseInt("0101", 2)));  
         System.out.println("二进制转十六进制:\t"+Integer.toHexString(Integer.parseInt("0101", 2)));  
           
         System.out.println();  
         System.out.println("1000的二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果"+Integer.highestOneBit(i));  
           
     }  
 
 
 
 

 
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);
    }
}

 
版权声明
 
本文原创作者：谷哥的小弟
作者博客地址：http://blog.csdn.net/lfdfhl
 
 
引子
 
今天，我们从一段非常简单的代码说起。
 
示例代码
 
package cn.com;
/**
* 本文作者：谷哥的小弟 
* 博客地址：http://blog.csdn.net/lfdfhl
* 示例描述：Integer缓存IntegerCache
*/
public class IntegerCacheTest {

	public static void main(String[] args) {
		Integer a=9527;
		Integer b=9527;
		System.out.println(a==b);	
		Integer c=97;
		Integer d=97;
		System.out.println(c==d);
	}

}
 
运行结果
 
请问，这段代码运行的结果是什么呢？两次输出的结果都是false，对不对？非也！！！
 

 从上图可以清楚地看到：
 
1、第一次输出的结果是false
2、第二次输出的结果是true
 
看此处，就有点丈二和尚摸不着头脑了。这是为什么呢？
 
源码剖析
 
在执行Integer a=9527;时会调用Integer类的静态方法public static Integer valueOf(int i)进行自动装箱，其源码如下：
 
public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
 
该方法的主要逻辑如下：
 
如果i >= IntegerCache.low && i <= IntegerCache.high则调用IntegerCache.cache[i + (-IntegerCache.low)]
如果i的值不满足i >= IntegerCache.low && i <= IntegerCache.high则调用new Integer(i)
 
顺着这条主线，我们继续探究Integer缓存IntegerCache。IntegerCache是Integer类中的静态内部类，用于缓存数据便于节省内存、提高性能。其源码如下：
 
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() {}
    }
 
从这里我们可以看出 ：
 
IntegerCache.low = -128
IntegerCache.high = 127
缓冲区cache是一个Integer类型的数组
 
也就是说：IntegerCache缓存区间为[-128,127]。所以，在调用Integer.valueOf(int i)方法进行自动装箱时假若i的值在[-128,127]区间则生成的Integer对象会被存入缓冲区。当再次对该值进行装箱时会先去缓冲区中获取；如果取到则返回，如果没有取到则创建包装类对象存入缓冲区并返回。
 
嗯哼，看到这里是不是可以理解之前的那小段代码了呢？
 
扩展与延伸
 
除了Integer之外，在其他包装类(例如：Byte，Short，Long等)中也存在类似的设计。
 
 

 

Integer是包装类（引用数据类型），int是基本数据类型，
 
Integer a=12;
Integer b=12;
//a==b为true；
Integer c=1200;
Integer d=1200;
//c==d为false；
Integer e=new Integer(1);
Integer f=new Integer(1);
//e==f为false
 
引用数据类型对比需要用equals()方法对比相等
 因Integer存在缓存，
 在Integer的值不超过-128~127之间==对比为true，
 若超过则会new一个Integer对象==结果为false；
 在比较时可使用(a.intValue==b)来比较，
 用Integer和int对比Intege会自动拆箱变成int类型，所以结果就是int类型对比int类型了
 总结：对象之间的比较不能用==，包括数字包装类，Integer，Long，Short，Character，Byte，都存在缓存机制，数字大于对应的缓存池就会new一个对象，就不能用==了，若小于缓存池，则包装类不会创建新的对象