java.lang基礎數據類型boolean、char、byte、short、int、long、float、double (JDK1.8)

java.lang.Boolean

    public static int hashCode(boolean value) {
        return value ? 1231 : 1237;
    }

JDK 1.8新增一個hashCode方法，true的hashCode為1231，false的hashCode為1237， why？

https://stackoverflow.com/questions/3912303/boolean-hashcode

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

在類中定義了兩個public static final的變量，在創建Boolean對象的時候可以

    public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);

在創建Boolean對象的時候整個項目如果都是采用valueOf方法來創建，則整個項目就都會使用的這兩個對象了。

    public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }
    public static Boolean valueOf(String s) {
        return parseBoolean(s) ? TRUE : FALSE;
    }

剩下的Byte、Short、Integer、Long、Float、Double都是繼承自Number類，除此之外還有BigDecimal和BigInteger類。

下面總結下基礎數據類型的數值范圍

數據類型	字節	范圍
boolean	1	true或false
char	2	從字符型對應的整型數來划分，其表示范圍是0～65535
byte	1	-128～127
short	2	-32768～32767
int	4	-2147483648～2147483647 (-2^31 ~ 2^31-1)
long	8	-9223372036854775808 ~ 9223372036854775807
float	4	-3.4E38～3.4E38
double	8	-1.7E308～1.7E308

 

 

 

 

 

 

 

 

java.lang.Integer

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

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

    // Requires positive x
    static int stringSize(int x) {
        for (int i=0; ; i++)
            if (x <= sizeTable[i])
                return i+1;
    }

    final static char [] 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',
        } ;

    final static char [] 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',
        } ;

感覺這個toString方法實現的太巧妙了，為了減少運算真是無所不用其極，忍不住將這一整段的代碼都貼出來了。

stringSize方法是計算整個正整數x有多少個字符，如此就可以預先計算出一個整型轉換為字符數組要提前分配多少空間。這個方法的實現是通過比較大小實現的，預先定義好一個從小到大的數組sizeTable，配合下標確定size。

getChars方法是將整型i轉換為一個字符數組buf，其中index參數是整型i中包含的字符數，也即buf需要多少長度來存儲轉換后的整型。在方法中如果整型i >= 65536，則通過q = i/100;  r = i - q * 100;的方式將數字拆分成兩個部分，其中r為i的前兩位。高潮來了，看他怎么實現的獲取這兩位的字符的，竟然用數組查詢的方式！當然，這是個while循環，會一直處理直到i<65536。再看下for循環中的將小於65536的數字轉換為字符數組。q = (i * 52429) >>> (16+3) 這一句其實是個除以10的操作，那為什么要用52429呢？524288 = 2^19， i * 52429 然后無符號右移19位，相當於52429/2^19 = 0.100000381，近似是等於i/10（移位運算遠比除法快，也是一種優化策略）。那為什么要選擇2^19呢？參考了下知乎的回答：java源碼中Integer.class中有個getChars方法，里面有個52429是怎么確定的？。然后我又計算了下2^20和2^21，結果竟然等於2^19，然后2^22精度就更高一些，但也沒有太大的必要了。

    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() {}
    }

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

通過IntegerCache內部類將常用的整數存儲起來，當使用valueOf的方式構造Integer對象的時候，會直接從IntegerCache中取值。IntegerCache的最小值固定為-128，最大值可以通過java.lang.Integer.IntegerCache.high設置。

java.lang.Byte

在Byte類中同樣是有個ByteCache緩存的緩存了從-128到正的127的byte，也就是byte的取值范圍都被緩存了。通過下面的valueOf就可以使用到ByteCache類中的緩存值了。

    public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
    }

Byte中的很多函數都是將byte轉換成int然后再操作的。 

java.lang.Short

Short類中也同樣有個ShortCache緩存，緩存了從-128到127的整數，不過要注意short是兩個字節的。同樣的使用ValueOf可以使用緩存中的內容。

    private static class ShortCache {
        private ShortCache(){}

        static final Short cache[] = new Short[-(-128) + 127 + 1];

        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Short((short)(i - 128));
        }
    }

    public static Short valueOf(short s) {
        final int offset = 128;
        int sAsInt = s;
        if (sAsInt >= -128 && sAsInt <= 127) { // must cache
            return ShortCache.cache[sAsInt + offset];
        }
        return new Short(s);
    }

    public static short reverseBytes(short i) {
        return (short) (((i & 0xFF00) >> 8) | (i << 8));
    }

在Short類中還有個reverseBytes函數，將高位字節和低位字節互換位置。不知道這樣做有什么用途。

java.lang.Long

同樣的在Long類中toString方法實現類似於Integer中的toString方法，不再贅述。

在緩存方面，Long類中同樣有個LongCache緩存類，緩存了-128L~127L的Long對象，通過valueOf可以直接獲取緩存中的類對象。

在JDK 1.8中，增加了以下幾個方法

    // 比較兩個long
    // @since 1.7
    public static int compare(long x, long y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

    // 比較兩個unsigned long
    // @since 1.8
    public static int compareUnsigned(long x, long y) {
        return compare(x + MIN_VALUE, y + MIN_VALUE);
    }

    // 除法運算，結果是除得的結果，余數采用remainderUnsigned獲得
    // @since 1.8
    public static long divideUnsigned(long dividend, long divisor) {
        if (divisor < 0L) { // signed comparison
            // Answer must be 0 or 1 depending on relative magnitude
            // of dividend and divisor.
            return (compareUnsigned(dividend, divisor)) < 0 ? 0L :1L;
        }

        if (dividend > 0) //  Both inputs non-negative
            return dividend/divisor;
        else {
            /*
             * For simple code, leveraging BigInteger.  Longer and faster
             * code written directly in terms of operations on longs is
             * possible; see "Hacker's Delight" for divide and remainder
             * algorithms.
             */
            return toUnsignedBigInteger(dividend).
                divide(toUnsignedBigInteger(divisor)).longValue();
        }
    }

    // 除法運算，結果是余數
    // @since 1.8
    public static long remainderUnsigned(long dividend, long divisor) {
        if (dividend > 0 && divisor > 0) { // signed comparisons
            return dividend % divisor;
        } else {
            if (compareUnsigned(dividend, divisor) < 0) // Avoid explicit check for 0 divisor
                return dividend;
            else
                return toUnsignedBigInteger(dividend).
                    remainder(toUnsignedBigInteger(divisor)).longValue();
        }
    }

另外增加了sum方法，如下面的代碼，代碼中並沒有考慮溢出問題，所以謹慎調用。

    public static long sum(long a, long b) {
        return a + b;
    }

java.lang.Double

    public boolean equals(Object obj) {
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }

    public static long doubleToLongBits(double value) {
        long result = doubleToRawLongBits(value);
        // Check for NaN based on values of bit fields, maximum
        // exponent and nonzero significand.
        if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
              DoubleConsts.EXP_BIT_MASK) &&
             (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
            result = 0x7ff8000000000000L;
        return result;
    }

在Double類中，重載了equals方法，其中的doubleToRawLongBits是個native方法。

java.lang.Float

Float源碼和Double類方法差不多。就這樣結束吧。