java Integer与int详解 01

心得：
一周前和一位刚入职阿里蚂蚁金融的学长进行了一次会谈：总的来说，java学了一个学期，可能是急于求成（我身上最大的缺陷），就直接学JAVA的JDBC编程（MYSQL在大二上学期就开始在用了：2002 1064 HY2000 1042 2053等的错踩到心碎，不过踩坑不怕，重要的是你对MYSQL认识了多少，现在一般也是偷懒，很少写.sql建表啊等等操作，哈哈哈都是视图工具Navcat for mysql:需要的同学可以了解一下）
我清晰的记得我在学java第二天学的多线程，做了一个买面包的多线程小demo，说实话，现在已经忘的一干二净，可能唯一记住的就是sleep()函数了...个人心得：不管学什么，都得循序渐进
学长在“会谈”一直在强调基础，那么java基础是什么呢？一门语言的基础永远不会是老师讲的那些:类的访问权限、包的访问权限，static是一个类静态变量、怎么使用import啊等等肤浅到学了和没学一样的东西（可能是王某愚见....），学长考了我一道题:

   Integer a=200;
   Integer b=200;
   Integer a1=2;
   Integer b1=2;
   System.out.println(a==b); //false   1
   System.out.println(a1==b1); //true  2

我再加一个：   

  Integer c=new Integer(200);
  Integer d=new Integer(200);
  System.out.println(c==d); //false    3

很简单：我很快就说出了正确答案，但学长的问题来了：
  1.Integer对象和int数据类型的区别是什么？
  2.既然知道缓存，那么缓存到了哪里？为什么缓存？Integer、int的适用场景分别是什么？
  3.System.out.println(a.equals(b)); //true 为什么？ integer既然继承自Object，那么你能说一下Object都有什么方法吗?
  4.不同类型的equals()方法是相同的吗？

  5.既然知道自动装箱和自动拆箱，那么具体什么时候发生这种隐式转化？

首先是：

public final class Integer extends Number implements Comparable<Integer> {}
   //Integer 的类声明，第一句要注意三个点：Number类了解多少？Comparable<T>泛型比较接口了解多少？CompareTo()函数的实现原则？


  问题一：
   Integer 是int的包装类，在Integer对象里边包含了一个int基本类型的私有属性值

    /**
     * The value of the {@code Integer}.
     *
     * @serial
     */
    private final int value;

  并且Integer也提供了很多供我们使用的方法：
   我们从构造函数说起：
   1>.向构造函数传int值
  

public Integer(int value) {
        this.value = value; //为value赋值
    }

   也就是说，Integer c=new Integer(200);  这一行相当于是Integer对象里面的私有属性value的赋值

  2> Integer i=2;

  经过断点测试： 这一句代码会调用Integer的一个函数：ValueOf() 涉及到缓存（IntegerCache），在第二个问题里边会详细解释

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

还有很多ValueOf（）的重载函数：基本上都是parseInt()函数的调用

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

  3> 向构造函数传String字符串

public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10); //10为进制
    }
    public static int parseInt(String s, int radix)
                throws NumberFormatException   //数字格式异常
    {

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

        if (radix < Character.MIN_RADIX) { //java.lang.Character了解多少
            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;   //@Native public static final int MAX_VALUE = 0x7fffffff; @Native 了解多少？
        int multmin;
        int digit;

        if (len > 0) { //不为空
            char firstChar = s.charAt(0); //String类的操作方法了解多少
            if (firstChar < '0') { // Possible leading "+" or "-"   '-'<'0'&&'+'<'0' true  ASCLL码的比较  ‘1’<'0' 数据类型的自动转化 (String)‘1’=》(int)1 
 32                 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);  //java.lang.Character.digit()方法用法 : 在指定的基数(radix)返回字符ch的数值 //Character.digit('0',10)=0; Character.digit('a',10);=-1
                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;
    }

 4>Integer的ToString()实现（移位运算没看懂......）

 final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                  99999999, 999999999, Integer.MAX_VALUE };

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

    static int stringSize(int x) {
        for (int i=0; ; i++)
            if (x <= sizeTable[i]) //本人觉得这里是一个非常巧妙的设计
                return i+1;
    }

static void getChars(int i, int index, char[] buf) {
        int q, r;
        int charPos = index;
        char sign = 0;

        if (i < 0) {
            sign = '-';
            i = -i;
        }

        // Generate two digits per iteration
        while (i >= 65536) {
            q = i / 100;
        // really: r = i - (q * 100);
            r = i - ((q << 6) + (q << 5) + (q << 2));
            i = q;
            buf [--charPos] = DigitOnes[r];
            buf [--charPos] = DigitTens[r];
        }

        // Fall thru to fast mode for smaller numbers
        // assert(i <= 65536, i);
        for (;;) {
            q = (i * 52429) >>> (16+3);  //????这个为什么是52429我也不知道......但是如果你打几个断点...看看结果还是能看懂的....hhh
            r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...
            buf [--charPos] = digits [r];
            i = q;
            if (i == 0) break;
        }
        if (sign != 0) {
            buf [--charPos] = sign;
        }
    }

 当然还有很多函数，比如：

public static Integer getInteger(String nm, Integer val)：返回具有指定名称的系统属性的整数值：注意是返回一个系统属性的属性值,

问题又来了：System 系统类了解多少???(走到哪里都会引发一堆一堆的问题.....最后一定要总结)，我就给大家粘贴一下代码吧：

 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, 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;
    }
 public static Integer decode(String nm) throws NumberFormatException {
        int radix = 10;
        int index = 0;
        boolean negative = false;
        Integer result;

        if (nm.length() == 0)
            throw new NumberFormatException("Zero length string");
        char firstChar = nm.charAt(0);
        // 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 += 2;
            radix = 16;
        }
        else if (nm.startsWith("#", index)) {
            index ++;
            radix = 16;
        }
        else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
            index ++;
            radix = 8;
        }

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

 第二个问题：缓存（IntegerCache）先上代码：

 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  high的值可能取决于不同的操作系统，
               //据查阅：在jav5之前，缓存范围是写死在-128-127之间的，但是在 Java 6 中，
               //最大值映射到 java.lang.Integer.IntegerCache.high，可以使用 JVM 的启动参数设置最大值。
               //这使我们可以根据应用程序的实际情况灵活地调整来提高性能，
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
                  //之前一直认为Integer是缓存在JVM里边的，原来是自己没有充分认识到JVM、JDK、JRE的真正区别。
                  //查阅资料后，Integer是缓存在JDK里的.....虽然现在也不是很理解
               String a = sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");//???
               我尝试了一下，疑惑加一
              //String b = sun.misc.VM.getSavedProperty("high"); =》null
              //String c = System.getProperty("java.lang.Integer.IntegerCache.high"); =》null
              //String d = System.getProperty("high"); =》null？？？？？
            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缓存类：再来看ValueOf函数（）

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

Integer a=1；

Integer b=1；

Integer c=200；

Integer d=200；

调用valueOf函数之后，确定i是否在缓存范围内，如果在，返回已经缓存下来的，如果不在，就返回一个新的Integer对象

故：a和b其实指向的是同一个Integer对象，c和d返回两个 堆地址不同的但是value相同的Integer对象。

引用类型存在堆中，基本类型与引用存在栈中，这是再基本不过的操作...

补充：

这种缓存行为不仅适用于Integer对象。我们针对所有整数类型的类都有类似的缓存机制。
有 ByteCache 用于缓存 Byte 对象
有 ShortCache 用于缓存 Short 对象
有 LongCache 用于缓存 Long 对象
有 CharacterCache 用于缓存 Character 对象
Byte，Short，Long 有固定范围: -128 到 127。对于 Character, 范围是 0 到 127。除了 Integer 可以通过参数改变范围外，其它的都不行。

  第三个问题：equals()函数

/**
     * Returns the value of this {@code Integer} as an
     * {@code int}.
     */
    public int intValue() {
        return value;
    }

 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }
7     
8     Integer a=200;
9     Integer  b=200;
10    a.equals(b)   //true 实际比较的是包装类中的value值，（int）200和（int）200必定会相等，这就解决了缓存带来的差异 
 

接下来我将贴几个equals():

String类的

 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true; //栈里指向堆的地址相同==引用指向通过一个对象
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false; //char数组的依次比较，String中的value又是什么呢？
                    i++;
                }
                return true;
            }
        }
        return false;
    }

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
 ......
}

Object 的equals()

 public boolean equals(Object obj) {
        return (this == obj);
    }

Object作为所有对象的直接父类...大多数的对象都是要重写equals函数；

第四个问题：Object的函数：
这个我本来就知道toString()、hasCode()、equals()、clone();

但是通过看了看源码:发现Thread类继承自Object，所以必然会有有关线程的函数...那么问题来了...run()、sleep()又是哪里来的？？？？

public final native void notify();

public final native void notifyAll();

public final native void wait(long timeout) throws InterruptedException;

第五个问题：autoboxing、unboxing https://www.cnblogs.com/wang-yaz/p/8516151.html

有一个前辈的博客写的很灵性：两句总结完毕

 Integer a = 99; //自动装箱 相当于调用了Integer的valueOf()函数
 int b = a;//自动拆箱 调用了intValue()函数

Integer a1=10;
int a2=10;
System.out.println(a2==a1)  //true 懂了原理，这题也太简单了：原理：包装类和基本类型进行运算时,隐式自动拆箱......

之前写的：java基本数据类型的博客：
   https://www.cnblogs.com/laiso/p/8672524.html

遗留的问题：

1.移位运算

2.@Native

3.Character类

4.Number类

5.String 类

6.断言

7.System类