Skip to main content
 首页 » 编程设计

java中封装类2

2022年07月27日84kenshinobiy

java中的数字类型包括 Byte,Short,Integer,Long,Float,Double.其中前四个是整数,后两个是浮点数。 在说java中数字类型之前先来看看它们统一的基类Number。

package java.lang; 
 
public abstract class Number implements java.io.Serializable { 
 
    public abstract int intValue(); 
 
    public abstract long longValue(); 
 
    public abstract float floatValue(); 
 
    public abstract double doubleValue(); 
 
    public byte byteValue() { 
        return (byte)intValue(); 
    } 
 
    public short shortValue() { 
        return (short)intValue(); 
    } 
 
    private static final long serialVersionUID = -8742448824652078965L; 
}

代码并不复杂,从代码可以看出数字类型的封装类可以转化为任意数字类型,也就是说数字类型是可以相互转化的。

首先概括的说一下这六个类型都是数字类型,都包含了这四个静态字段,分别是

Size代表数据二进制位的长度,MAX_VALUE最大值,MIN_VALUE最小值,和TYPE对应的基元类型的Class

需要特别说明的是 TYPE虽然也是Class<Long>,但是它和 Long.class的Class不是同一个对象。因为java的泛型是伪泛型,<>中的类型,只是代表该类型的对象可以强转为<>中的类型。

package demo.nio; 
 
public class NumberDemo { 
 
    public static void main(String[] args) { 
         
         
        System.out.println(Long.class.getName());//java.lang.Long 
        System.out.println(Long.TYPE.getName());//long 
    } 
 
}

四个整型类型的数据中,Byte的Size是8,也就是一个字节,Short的SIZE是16,也就是两个字节,Integer是32也就是4个字节,Long的SIZE是64也就是8个字节,它们的最大,最小值随长度的大小而变化,长度越大,最大值越大,最小值越小。

package demo.nio; 
 
public class NumberDemo { 
 
    public static void main(String[] args) { 
        System.out.println(Byte.MAX_VALUE);//127 
        System.out.println(Byte.MIN_VALUE);//-128 
         
        System.out.println(Short.MAX_VALUE);//32767 
        System.out.println(Short.MIN_VALUE);//-32768 
         
        System.out.println(Integer.MAX_VALUE);//2147483647 
        System.out.println(Integer.MIN_VALUE);//-2147483648 
         
        System.out.println(Long.MAX_VALUE);//9223372036854775807 
        System.out.println(Long.MIN_VALUE);//-9223372036854775808 
    } 
 
}

先说Byte类型,Byte就是一个字节,代表8个二进制位。内部有一个value字段,用于存放装箱前的数据。而这个封装类的hashCode就是该value,数字类型都包含这样几个静态函数:

valueOf(XXX v)

valueOf(String s, int radix)

valueOf(String s)

parseXXX(String s)

parseXXX(String s, int radix)

decode(String nm)

其中Byte的parse和decode都是调用Integer的方法实现的。其中parse用于转化普通数字,decode用于转化 0xa之类的数字。

package java.lang; 
 
public final class Byte extends Number implements Comparable<Byte> { 
 
    public static final byte   MIN_VALUE = -128; 
 
    public static final byte   MAX_VALUE = 127; 
 
    public static final Class<Byte> TYPE = (Class<Byte>) Class.getPrimitiveClass("byte"); 
 
    public static String toString(byte b) { 
        return Integer.toString((int)b, 10); 
    } 
 
    private static class ByteCache { 
        private ByteCache(){} 
 
        static final Byte cache[] = new Byte[-(-128) + 127 + 1]; 
 
        static { 
            for(int i = 0; i < cache.length; i++) 
                cache[i] = new Byte((byte)(i - 128)); 
        } 
    } 
 
    public static Byte valueOf(byte b) { 
        final int offset = 128; 
        return ByteCache.cache[(int)b + offset]; 
    } 
 
    public static byte parseByte(String s, int radix)throws NumberFormatException { 
        int i = Integer.parseInt(s, radix); 
        if (i < MIN_VALUE || i > MAX_VALUE) 
            throw new NumberFormatException( 
                "Value out of range. Value:\"" + s + "\" Radix:" + radix); 
        return (byte)i; 
    } 
 
    public static byte parseByte(String s) throws NumberFormatException { 
        return parseByte(s, 10); 
    } 
 
    public static Byte valueOf(String s, int radix) 
        throws NumberFormatException { 
        return valueOf(parseByte(s, radix)); 
    } 
 
    public static Byte valueOf(String s) throws NumberFormatException { 
        return valueOf(s, 10); 
    } 
 
    public static Byte decode(String nm) throws NumberFormatException { 
        int i = Integer.decode(nm); 
        if (i < MIN_VALUE || i > MAX_VALUE) 
            throw new NumberFormatException( 
                    "Value " + i + " out of range from input " + nm); 
        return valueOf((byte)i); 
    } 
 
    private final byte value; 
 
    public Byte(byte value) { 
        this.value = value; 
    } 
 
    public Byte(String s) throws NumberFormatException { 
        this.value = parseByte(s, 10); 
    } 
 
    public byte byteValue() { 
        return value; 
    } 
 
    public short shortValue() { 
        return (short)value; 
    } 
 
    public int intValue() { 
        return (int)value; 
    } 
 
    public long longValue() { 
        return (long)value; 
    } 
 
    public float floatValue() { 
        return (float)value; 
    } 
 
    public double doubleValue() { 
        return (double)value; 
    } 
 
    public String toString() { 
        return Integer.toString((int)value); 
    } 
 
    public int hashCode() { 
        return (int)value; 
    } 
 
    public boolean equals(Object obj) { 
        if (obj instanceof Byte) { 
            return value == ((Byte)obj).byteValue(); 
        } 
        return false; 
    } 
 
    public int compareTo(Byte anotherByte) { 
        return compare(this.value, anotherByte.value); 
    } 
 
    public static int compare(byte x, byte y) { 
        return x - y; 
    } 
 
    public static final int SIZE = 8; 
 
    private static final long serialVersionUID = -7183698231559129828L; 
}

因为数字类型都实现了Comparable接口,也就是说他是可比较的类型,对于Byte compare的实现就是简单的减去,除此之外还有个ByteCache,存放了-128~127的装箱类型的数组。

valueOf(byte b)返回的就是Cache中的数据。

package demo.nio; 
 
public class NumberDemo { 
    public static void main(String[] args) { 
        System.out.println(Byte.valueOf((byte) 10)); 
        System.out.println(Byte.valueOf("10")); 
        System.out.println(Byte.valueOf("10",10)); 
        System.out.println(Byte.parseByte("a",16)); 
        System.out.println(Byte.parseByte("10")); 
        System.out.println(Byte.decode("10")); 
        System.out.println(Byte.decode("0xa"));//10 
    } 
}

Short和Byte类型基本相同,valueOf,parseXXX,decode也是调用的Integer实现的,不过这里多了一个,reverseBytes(short i)函数,该函数的功能是将short数据反转,就是后八位变成前8位,前八位变成后八位。

如:0x100,反转之后就是0x1,0xa00反转之后就是10

Integer类型相对于前边的两个数字类型就复杂的多

首先它实现了parseXXX函数,toString函数,其次它多了很多静态函数。

package java.lang; 
 
import java.util.Properties; 
 
public final class Integer extends Number implements Comparable<Integer> { 
 
    public static final int   MIN_VALUE = 0x80000000; 
 
    public static final int   MAX_VALUE = 0x7fffffff; 
 
    public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("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; 
 
        /* Use the faster version */ 
        if (radix == 10) { 
            return toString(i); 
        } 
 
        char buf[] = new char[33]; 
        boolean negative = (i < 0); 
        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)); 
    } 
 
    public static String toHexString(int i) { 
        return toUnsignedString(i, 4); 
    } 
 
    public static String toOctalString(int i) { 
        return toUnsignedString(i, 3); 
    } 
 
    public static String toBinaryString(int i) { 
        return toUnsignedString(i, 1); 
    } 
 
    /** 
     * Convert the integer to an unsigned number. 
     */ 
    private static String toUnsignedString(int i, int shift) { 
        char[] buf = new char[32]; 
        int charPos = 32; 
        int radix = 1 << shift; 
        int mask = radix - 1; 
        do { 
            buf[--charPos] = digits[i & mask]; 
            i >>>= shift; 
        } while (i != 0); 
 
        return new String(buf, charPos, (32 - charPos)); 
    } 
 
 
    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', 
        } ; 
 
    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; 
    } 
 
    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; 
    } 
 
    public static int parseInt(String s) throws NumberFormatException { 
        return parseInt(s,10); 
    } 
 
    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)); 
    } 
 
 
    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) { 
                int i = parseInt(integerCacheHighPropValue); 
                i = Math.max(i, 127); 
                // Maximum array size is Integer.MAX_VALUE 
                h = Math.min(i, Integer.MAX_VALUE - (-low)); 
            } 
            high = h; 
 
            cache = new Integer[(high - low) + 1]; 
            int j = low; 
            for(int k = 0; k < cache.length; k++) 
                cache[k] = new Integer(j++); 
        } 
 
        private IntegerCache() {} 
    } 
 
    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); 
    } 
 
    private final int value; 
 
    public Integer(int value) { 
        this.value = value; 
    } 
 
    public Integer(String s) throws NumberFormatException { 
        this.value = parseInt(s, 10); 
    } 
 
    public byte byteValue() { 
        return (byte)value; 
    } 
 
    public short shortValue() { 
        return (short)value; 
    } 
 
    public int intValue() { 
        return value; 
    } 
 
    public long longValue() { 
        return (long)value; 
    } 
 
    public float floatValue() { 
        return (float)value; 
    } 
 
    public double doubleValue() { 
        return (double)value; 
    } 
 
    public String toString() { 
        return toString(value); 
    } 
 
    public int hashCode() { 
        return value; 
    } 
 
    public boolean equals(Object obj) { 
        if (obj instanceof Integer) { 
            return value == ((Integer)obj).intValue(); 
        } 
        return false; 
    } 
 
    public static Integer getInteger(String nm) { 
        return getInteger(nm, null); 
    } 
 
    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 e) { 
        } catch (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; 
    } 
 
    public int compareTo(Integer anotherInteger) { 
        return compare(this.value, anotherInteger.value); 
    } 
 
    public static int compare(int x, int y) { 
        return (x < y) ? -1 : ((x == y) ? 0 : 1); 
    } 
 
    public static final int SIZE = 32; 
 
    public static int highestOneBit(int i) { 
        // HD, Figure 3-1 
        i |= (i >>  1); 
        i |= (i >>  2); 
        i |= (i >>  4); 
        i |= (i >>  8); 
        i |= (i >> 16); 
        return i - (i >>> 1); 
    } 
 
    public static int lowestOneBit(int i) { 
        // HD, Section 2-1 
        return i & -i; 
    } 
 
    public static int numberOfLeadingZeros(int i) { 
        // HD, Figure 5-6 
        if (i == 0) 
            return 32; 
        int n = 1; 
        if (i >>> 16 == 0) { n += 16; i <<= 16; } 
        if (i >>> 24 == 0) { n +=  8; i <<=  8; } 
        if (i >>> 28 == 0) { n +=  4; i <<=  4; } 
        if (i >>> 30 == 0) { n +=  2; i <<=  2; } 
        n -= i >>> 31; 
        return n; 
    } 
 
    public static int numberOfTrailingZeros(int i) { 
        // HD, Figure 5-14 
        int y; 
        if (i == 0) return 32; 
        int n = 31; 
        y = i <<16; if (y != 0) { n = n -16; i = y; } 
        y = i << 8; if (y != 0) { n = n - 8; i = y; } 
        y = i << 4; if (y != 0) { n = n - 4; i = y; } 
        y = i << 2; if (y != 0) { n = n - 2; i = y; } 
        return n - ((i << 1) >>> 31); 
    } 
 
    public static int bitCount(int i) { 
        // HD, Figure 5-2 
        i = i - ((i >>> 1) & 0x55555555); 
        i = (i & 0x33333333) + ((i >>> 2) & 0x33333333); 
        i = (i + (i >>> 4)) & 0x0f0f0f0f; 
        i = i + (i >>> 8); 
        i = i + (i >>> 16); 
        return i & 0x3f; 
    } 
 
    public static int rotateLeft(int i, int distance) { 
        return (i << distance) | (i >>> -distance); 
    } 
 
    public static int rotateRight(int i, int distance) { 
        return (i >>> distance) | (i << -distance); 
    } 
 
    public static int reverse(int i) { 
        // HD, Figure 7-1 
        i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555; 
        i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333; 
        i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f; 
        i = (i << 24) | ((i & 0xff00) << 8) | 
            ((i >>> 8) & 0xff00) | (i >>> 24); 
        return i; 
    } 
 
    public static int signum(int i) { 
        // HD, Section 2-7 
        return (i >> 31) | (-i >>> 31); 
    } 
 
    public static int reverseBytes(int i) { 
        return ((i >>> 24)           ) | 
               ((i >>   8) &   0xFF00) | 
               ((i <<   8) & 0xFF0000) | 
               ((i << 24)); 
    } 
 
    /** use serialVersionUID from JDK 1.0.2 for interoperability */ 
    private static final long serialVersionUID = 1360826667806852920L; 
}

compare的实现是如果大于返回1,小于返回-1而不是简单的减。hashCode也是内部的value字段。而它的Cache就没有维护全部的数据而是-128-127,valueOf函数的操作是如果在这个范围内则返回cache中的值,否则new一个返回。

它的toString系列,比较复杂,toHexString 16进制 toOctalString 8进制 toBinaryString 2进制 toString转化为十进制,他还有一个重载版本toString(int i, int radix) 转化为指定进制。

parseXXX 系列 parseInt(String s)转化为10进制数据,parseInt(String s, int radix)转化为指定进制

highestOneBit,lowestOneBit 只保留最高位的1和最低位1的结果。

bitCount 二进制数据1的个数

numberOfLeadingZeros,numberOfTrailingZeros 开头和末尾0的个数

signum 如果大于0,返回1,小于返回-1,等于0返回0

reverseBytes反转数字,高位变低位,4到1位,3到二位,2到三位,1到四位

package demo.nio; 
 
public class NumberDemo { 
    public static void main(String[] args) { 
         
        System.out.println(Integer.toBinaryString(255)); 
        System.out.println(Integer.toHexString(255)); 
        System.out.println(Integer.toOctalString(255)); 
         
        System.out.println(Integer.highestOneBit(-8));//-2147483648 
         
        System.out.println(Integer.bitCount(255));//8 
         
        System.out.println(Integer.lowestOneBit(-8));//8 
        System.out.println(Integer.numberOfLeadingZeros(-8));//0 
        System.out.println(Integer.numberOfTrailingZeros(-8));//3 
         
        System.out.println(Integer.signum(100));//1 
        System.out.println(Integer.signum(-100));//-1 
        System.out.println(Integer.signum(0));//0 
         
        System.out.println(Integer.toBinaryString(128)); 
        System.out.println(Integer.toBinaryString(Integer.reverseBytes(128))); 
        System.out.println(Integer.reverseBytes(128));//0 
    } 
     
}

Long和Integer功能就比较类似,只是因为Long是64位,所以所有的函数都要重新实现。

package java.lang; 
 
public final class Long extends Number implements Comparable<Long> { 
 
    public static final long MIN_VALUE = 0x8000000000000000L; 
 
    public static final long MAX_VALUE = 0x7fffffffffffffffL; 
 
    public static final Class<Long> TYPE = (Class<Long>) Class.getPrimitiveClass("long"); 
 
    public static String toString(long i, int radix) { 
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) 
            radix = 10; 
        if (radix == 10) 
            return toString(i); 
        char[] buf = new char[65]; 
        int charPos = 64; 
        boolean negative = (i < 0); 
 
        if (!negative) { 
            i = -i; 
        } 
 
        while (i <= -radix) { 
            buf[charPos--] = Integer.digits[(int)(-(i % radix))]; 
            i = i / radix; 
        } 
        buf[charPos] = Integer.digits[(int)(-i)]; 
 
        if (negative) { 
            buf[--charPos] = '-'; 
        } 
 
        return new String(buf, charPos, (65 - charPos)); 
    } 
 
    public static String toHexString(long i) { 
        return toUnsignedString(i, 4); 
    } 
 
    public static String toOctalString(long i) { 
        return toUnsignedString(i, 3); 
    } 
 
    public static String toBinaryString(long i) { 
        return toUnsignedString(i, 1); 
    } 
 
    private static String toUnsignedString(long i, int shift) { 
        char[] buf = new char[64]; 
        int charPos = 64; 
        int radix = 1 << shift; 
        long mask = radix - 1; 
        do { 
            buf[--charPos] = Integer.digits[(int)(i & mask)]; 
            i >>>= shift; 
        } while (i != 0); 
        return new String(buf, charPos, (64 - charPos)); 
    } 
 
    public static String toString(long i) { 
        if (i == Long.MIN_VALUE) 
            return "-9223372036854775808"; 
        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(long i, int index, char[] buf) { 
        long q; 
        int r; 
        int charPos = index; 
        char sign = 0; 
 
        if (i < 0) { 
            sign = '-'; 
            i = -i; 
        } 
 
        // Get 2 digits/iteration using longs until quotient fits into an int 
        while (i > Integer.MAX_VALUE) { 
            q = i / 100; 
            // really: r = i - (q * 100); 
            r = (int)(i - ((q << 6) + (q << 5) + (q << 2))); 
            i = q; 
            buf[--charPos] = Integer.DigitOnes[r]; 
            buf[--charPos] = Integer.DigitTens[r]; 
        } 
 
        // Get 2 digits/iteration using ints 
        int q2; 
        int i2 = (int)i; 
        while (i2 >= 65536) { 
            q2 = i2 / 100; 
            // really: r = i2 - (q * 100); 
            r = i2 - ((q2 << 6) + (q2 << 5) + (q2 << 2)); 
            i2 = q2; 
            buf[--charPos] = Integer.DigitOnes[r]; 
            buf[--charPos] = Integer.DigitTens[r]; 
        } 
 
        // Fall thru to fast mode for smaller numbers 
        // assert(i2 <= 65536, i2); 
        for (;;) { 
            q2 = (i2 * 52429) >>> (16+3); 
            r = i2 - ((q2 << 3) + (q2 << 1));  // r = i2-(q2*10) ... 
            buf[--charPos] = Integer.digits[r]; 
            i2 = q2; 
            if (i2 == 0) break; 
        } 
        if (sign != 0) { 
            buf[--charPos] = sign; 
        } 
    } 
 
    // Requires positive x 
    static int stringSize(long x) { 
        long p = 10; 
        for (int i=1; i<19; i++) { 
            if (x < p) 
                return i; 
            p = 10*p; 
        } 
        return 19; 
    } 
 
    public static long parseLong(String s, int radix)throws NumberFormatException{ 
        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"); 
        } 
 
        long result = 0; 
        boolean negative = false; 
        int i = 0, len = s.length(); 
        long limit = -Long.MAX_VALUE; 
        long multmin; 
        int digit; 
 
        if (len > 0) { 
            char firstChar = s.charAt(0); 
            if (firstChar < '0') { // Possible leading "+" or "-" 
                if (firstChar == '-') { 
                    negative = true; 
                    limit = Long.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; 
    } 
 
    public static long parseLong(String s) throws NumberFormatException { 
        return parseLong(s, 10); 
    } 
 
    public static Long valueOf(String s, int radix) throws NumberFormatException { 
        return Long.valueOf(parseLong(s, radix)); 
    } 
 
    public static Long valueOf(String s) throws NumberFormatException 
    { 
        return Long.valueOf(parseLong(s, 10)); 
    } 
 
    private static class LongCache { 
        private LongCache(){} 
 
        static final Long cache[] = new Long[-(-128) + 127 + 1]; 
 
        static { 
            for(int i = 0; i < cache.length; i++) 
                cache[i] = new Long(i - 128); 
        } 
    } 
 
    public static Long valueOf(long l) { 
        final int offset = 128; 
        if (l >= -128 && l <= 127) { // will cache 
            return LongCache.cache[(int)l + offset]; 
        } 
        return new Long(l); 
    } 
 
    public static Long decode(String nm) throws NumberFormatException { 
        int radix = 10; 
        int index = 0; 
        boolean negative = false; 
        Long 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 = Long.valueOf(nm.substring(index), radix); 
            result = negative ? Long.valueOf(-result.longValue()) : result; 
        } catch (NumberFormatException e) { 
            // If number is Long.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 = Long.valueOf(constant, radix); 
        } 
        return result; 
    } 
 
    private final long value; 
 
    public Long(long value) { 
        this.value = value; 
    } 
 
    public Long(String s) throws NumberFormatException { 
        this.value = parseLong(s, 10); 
    } 
 
    public byte byteValue() { 
        return (byte)value; 
    } 
 
    public short shortValue() { 
        return (short)value; 
    } 
 
    public int intValue() { 
        return (int)value; 
    } 
 
    public long longValue() { 
        return (long)value; 
    } 
 
    public float floatValue() { 
        return (float)value; 
    } 
 
    public double doubleValue() { 
        return (double)value; 
    } 
 
    public String toString() { 
        return toString(value); 
    } 
 
    public int hashCode() { 
        return (int)(value ^ (value >>> 32)); 
    } 
 
    public boolean equals(Object obj) { 
        if (obj instanceof Long) { 
            return value == ((Long)obj).longValue(); 
        } 
        return false; 
    } 
 
    public static Long getLong(String nm) { 
        return getLong(nm, null); 
    } 
 
    public static Long getLong(String nm, long val) { 
        Long result = Long.getLong(nm, null); 
        return (result == null) ? Long.valueOf(val) : result; 
    } 
 
    public static Long getLong(String nm, Long val) { 
        String v = null; 
        try { 
            v = System.getProperty(nm); 
        } catch (IllegalArgumentException e) { 
        } catch (NullPointerException e) { 
        } 
        if (v != null) { 
            try { 
                return Long.decode(v); 
            } catch (NumberFormatException e) { 
            } 
        } 
        return val; 
    } 
 
    public int compareTo(Long anotherLong) { 
        return compare(this.value, anotherLong.value); 
    } 
 
    public static int compare(long x, long y) { 
        return (x < y) ? -1 : ((x == y) ? 0 : 1); 
    } 
 
    public static final int SIZE = 64; 
 
    public static long highestOneBit(long i) { 
        // HD, Figure 3-1 
        i |= (i >>  1); 
        i |= (i >>  2); 
        i |= (i >>  4); 
        i |= (i >>  8); 
        i |= (i >> 16); 
        i |= (i >> 32); 
        return i - (i >>> 1); 
    } 
 
    public static long lowestOneBit(long i) { 
        // HD, Section 2-1 
        return i & -i; 
    } 
 
    public static int numberOfLeadingZeros(long i) { 
        // HD, Figure 5-6 
         if (i == 0) 
            return 64; 
        int n = 1; 
        int x = (int)(i >>> 32); 
        if (x == 0) { n += 32; x = (int)i; } 
        if (x >>> 16 == 0) { n += 16; x <<= 16; } 
        if (x >>> 24 == 0) { n +=  8; x <<=  8; } 
        if (x >>> 28 == 0) { n +=  4; x <<=  4; } 
        if (x >>> 30 == 0) { n +=  2; x <<=  2; } 
        n -= x >>> 31; 
        return n; 
    } 
 
    public static int numberOfTrailingZeros(long i) { 
        // HD, Figure 5-14 
        int x, y; 
        if (i == 0) return 64; 
        int n = 63; 
        y = (int)i; if (y != 0) { n = n -32; x = y; } else x = (int)(i>>>32); 
        y = x <<16; if (y != 0) { n = n -16; x = y; } 
        y = x << 8; if (y != 0) { n = n - 8; x = y; } 
        y = x << 4; if (y != 0) { n = n - 4; x = y; } 
        y = x << 2; if (y != 0) { n = n - 2; x = y; } 
        return n - ((x << 1) >>> 31); 
    } 
 
     public static int bitCount(long i) { 
        // HD, Figure 5-14 
        i = i - ((i >>> 1) & 0x5555555555555555L); 
        i = (i & 0x3333333333333333L) + ((i >>> 2) & 0x3333333333333333L); 
        i = (i + (i >>> 4)) & 0x0f0f0f0f0f0f0f0fL; 
        i = i + (i >>> 8); 
        i = i + (i >>> 16); 
        i = i + (i >>> 32); 
        return (int)i & 0x7f; 
     } 
 
    public static long rotateLeft(long i, int distance) { 
        return (i << distance) | (i >>> -distance); 
    } 
 
    public static long rotateRight(long i, int distance) { 
        return (i >>> distance) | (i << -distance); 
    } 
 
    public static long reverse(long i) { 
        // HD, Figure 7-1 
        i = (i & 0x5555555555555555L) << 1 | (i >>> 1) & 0x5555555555555555L; 
        i = (i & 0x3333333333333333L) << 2 | (i >>> 2) & 0x3333333333333333L; 
        i = (i & 0x0f0f0f0f0f0f0f0fL) << 4 | (i >>> 4) & 0x0f0f0f0f0f0f0f0fL; 
        i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL; 
        i = (i << 48) | ((i & 0xffff0000L) << 16) | 
            ((i >>> 16) & 0xffff0000L) | (i >>> 48); 
        return i; 
    } 
 
    public static int signum(long i) { 
        // HD, Section 2-7 
        return (int) ((i >> 63) | (-i >>> 63)); 
    } 
 
    public static long reverseBytes(long i) { 
        i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL; 
        return (i << 48) | ((i & 0xffff0000L) << 16) | 
            ((i >>> 16) & 0xffff0000L) | (i >>> 48); 
    } 
 
    /** use serialVersionUID from JDK 1.0.2 for interoperability */ 
    private static final long serialVersionUID = 4290774380558885855L; 
}

 Float,Double是浮点数,相较于整数就复杂的多,除了整数中几个静态字段外,它又多了很多静态字段

POSITIVE_INFINITY 正无穷 NEGATIVE_INFINITY 负无穷 NaN 非数字 MAX_EXPONENT 最大指数 MIN_EXPONENT 最小指数 NAN 非数字

所以浮点数都有两个函数,判断是否无穷大,是否非数字

Float的Size是32,Double是64

它的compare值得一提,public static native int floatToRawIntBits(float value); 是通过这个本地函数,转化为int来比较大小的。parseFloat和valueOf系列调用的是另一个包里的函数,

toString系列是调用Double小的toString

package java.lang; 
 
import sun.misc.FloatingDecimal; 
import sun.misc.FpUtils; 
import sun.misc.FloatConsts; 
import sun.misc.DoubleConsts; 
 
public final class Float extends Number implements Comparable<Float> { 
 
    public static final float POSITIVE_INFINITY = 1.0f / 0.0f; 
 
    public static final float NEGATIVE_INFINITY = -1.0f / 0.0f; 
 
    public static final float NaN = 0.0f / 0.0f; 
 
    public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f 
 
    public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f 
 
    public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f 
 
    public static final int MAX_EXPONENT = 127; 
 
    public static final int MIN_EXPONENT = -126; 
 
    public static final int SIZE = 32; 
 
    public static final Class<Float> TYPE = Class.getPrimitiveClass("float"); 
 
    public static String toString(float f) { 
        return new FloatingDecimal(f).toJavaFormatString(); 
    } 
 
    public static String toHexString(float f) { 
        if (Math.abs(f) < FloatConsts.MIN_NORMAL 
            &&  f != 0.0f ) {// float subnormal 
            String s = Double.toHexString(FpUtils.scalb((double)f, 
                                                        /* -1022+126 */ 
                                                        DoubleConsts.MIN_EXPONENT- 
                                                        FloatConsts.MIN_EXPONENT)); 
            return s.replaceFirst("p-1022$", "p-126"); 
        } 
        else // double string will be the same as float string 
            return Double.toHexString(f); 
    } 
 
    public static Float valueOf(String s) throws NumberFormatException { 
        return new Float(FloatingDecimal.readJavaFormatString(s).floatValue()); 
    } 
 
    public static Float valueOf(float f) { 
        return new Float(f); 
    } 
 
    public static float parseFloat(String s) throws NumberFormatException { 
        return FloatingDecimal.readJavaFormatString(s).floatValue(); 
    } 
 
    static public boolean isNaN(float v) { 
        return (v != v); 
    } 
 
    static public boolean isInfinite(float v) { 
        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY); 
    } 
 
    private final float value; 
 
    public Float(float value) { 
        this.value = value; 
    } 
 
    public Float(double value) { 
        this.value = (float)value; 
    } 
 
    public Float(String s) throws NumberFormatException { 
        // REMIND: this is inefficient 
        this(valueOf(s).floatValue()); 
    } 
 
    public boolean isNaN() { 
        return isNaN(value); 
    } 
 
    public boolean isInfinite() { 
        return isInfinite(value); 
    } 
 
    public String toString() { 
        return Float.toString(value); 
    } 
 
    public byte byteValue() { 
        return (byte)value; 
    } 
 
    public short shortValue() { 
        return (short)value; 
    } 
 
    public int intValue() { 
        return (int)value; 
    } 
 
    public long longValue() { 
        return (long)value; 
    } 
 
    public float floatValue() { 
        return value; 
    } 
 
    public double doubleValue() { 
        return (double)value; 
    } 
 
    public int hashCode() { 
        return floatToIntBits(value); 
    } 
 
    public boolean equals(Object obj) { 
        return (obj instanceof Float) 
               && (floatToIntBits(((Float)obj).value) == floatToIntBits(value)); 
    } 
 
    public static int floatToIntBits(float value) { 
        int result = floatToRawIntBits(value); 
        if ( ((result & FloatConsts.EXP_BIT_MASK) == 
              FloatConsts.EXP_BIT_MASK) && 
             (result & FloatConsts.SIGNIF_BIT_MASK) != 0) 
            result = 0x7fc00000; 
        return result; 
    } 
 
    public static native int floatToRawIntBits(float value); 
 
    public static native float intBitsToFloat(int bits); 
 
    public int compareTo(Float anotherFloat) { 
        return Float.compare(value, anotherFloat.value); 
    } 
 
    public static int compare(float f1, float f2) { 
        if (f1 < f2) 
            return -1;           // Neither val is NaN, thisVal is smaller 
        if (f1 > f2) 
            return 1;            // Neither val is NaN, thisVal is larger 
 
        // Cannot use floatToRawIntBits because of possibility of NaNs. 
        int thisBits    = Float.floatToIntBits(f1); 
        int anotherBits = Float.floatToIntBits(f2); 
 
        return (thisBits == anotherBits ?  0 : // Values are equal 
                (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN) 
                 1));                          // (0.0, -0.0) or (NaN, !NaN) 
    } 
 
    /** use serialVersionUID from JDK 1.0.2 for interoperability */ 
    private static final long serialVersionUID = -2671257302660747028L; 
}

Double跟Float相比,就是实现了toString的一个函数,其余基本相似

package java.lang; 
 
import sun.misc.FloatingDecimal; 
import sun.misc.FpUtils; 
import sun.misc.DoubleConsts; 
 
public final class Double extends Number implements Comparable<Double> { 
 
    public static final double POSITIVE_INFINITY = 1.0 / 0.0; 
 
    public static final double NEGATIVE_INFINITY = -1.0 / 0.0; 
 
    public static final double NaN = 0.0d / 0.0; 
 
    public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308 
 
    public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308 
 
    public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324 
 
    public static final int MAX_EXPONENT = 1023; 
 
    public static final int MIN_EXPONENT = -1022; 
 
    public static final int SIZE = 64; 
 
    public static final Class<Double>   TYPE = (Class<Double>) Class.getPrimitiveClass("double"); 
 
    public static String toString(double d) { 
        return new FloatingDecimal(d).toJavaFormatString(); 
    } 
 
    public static String toHexString(double d) { 
        /* 
         * Modeled after the "a" conversion specifier in C99, section 
         * 7.19.6.1; however, the output of this method is more 
         * tightly specified. 
         */ 
        if (!FpUtils.isFinite(d) ) 
            // For infinity and NaN, use the decimal output. 
            return Double.toString(d); 
        else { 
            // Initialized to maximum size of output. 
            StringBuffer answer = new StringBuffer(24); 
 
            if (FpUtils.rawCopySign(1.0, d) == -1.0) // value is negative, 
                answer.append("-");                  // so append sign info 
 
            answer.append("0x"); 
 
            d = Math.abs(d); 
 
            if(d == 0.0) { 
                answer.append("0.0p0"); 
            } 
            else { 
                boolean subnormal = (d < DoubleConsts.MIN_NORMAL); 
 
                // Isolate significand bits and OR in a high-order bit 
                // so that the string representation has a known 
                // length. 
                long signifBits = (Double.doubleToLongBits(d) 
                                   & DoubleConsts.SIGNIF_BIT_MASK) | 
                    0x1000000000000000L; 
 
                // Subnormal values have a 0 implicit bit; normal 
                // values have a 1 implicit bit. 
                answer.append(subnormal ? "0." : "1."); 
 
                // Isolate the low-order 13 digits of the hex 
                // representation.  If all the digits are zero, 
                // replace with a single 0; otherwise, remove all 
                // trailing zeros. 
                String signif = Long.toHexString(signifBits).substring(3,16); 
                answer.append(signif.equals("0000000000000") ? // 13 zeros 
                              "0": 
                              signif.replaceFirst("0{1,12}$", "")); 
 
                // If the value is subnormal, use the E_min exponent 
                // value for double; otherwise, extract and report d's 
                // exponent (the representation of a subnormal uses 
                // E_min -1). 
                answer.append("p" + (subnormal ? 
                               DoubleConsts.MIN_EXPONENT: 
                               FpUtils.getExponent(d) )); 
            } 
            return answer.toString(); 
        } 
    } 
 
    public static Double valueOf(String s) throws NumberFormatException { 
        return new Double(FloatingDecimal.readJavaFormatString(s).doubleValue()); 
    } 
 
    public static Double valueOf(double d) { 
        return new Double(d); 
    } 
 
    public static double parseDouble(String s) throws NumberFormatException { 
        return FloatingDecimal.readJavaFormatString(s).doubleValue(); 
    } 
 
    static public boolean isNaN(double v) { 
        return (v != v); 
    } 
 
    static public boolean isInfinite(double v) { 
        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY); 
    } 
 
    private final double value; 
 
    public Double(double value) { 
        this.value = value; 
    } 
 
    public Double(String s) throws NumberFormatException { 
        // REMIND: this is inefficient 
        this(valueOf(s).doubleValue()); 
    } 
 
    public boolean isNaN() { 
        return isNaN(value); 
    } 
 
    public boolean isInfinite() { 
        return isInfinite(value); 
    } 
 
    public String toString() { 
        return toString(value); 
    } 
 
    public byte byteValue() { 
        return (byte)value; 
    } 
 
    public short shortValue() { 
        return (short)value; 
    } 
 
    public int intValue() { 
        return (int)value; 
    } 
 
    public long longValue() { 
        return (long)value; 
    } 
 
    public float floatValue() { 
        return (float)value; 
    } 
 
    public double doubleValue() { 
        return (double)value; 
    } 
 
    public int hashCode() { 
        long bits = doubleToLongBits(value); 
        return (int)(bits ^ (bits >>> 32)); 
    } 
 
    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; 
    } 
 
    public static native long doubleToRawLongBits(double value); 
 
    public static native double longBitsToDouble(long bits); 
 
    public int compareTo(Double anotherDouble) { 
        return Double.compare(value, anotherDouble.value); 
    } 
 
    public static int compare(double d1, double d2) { 
        if (d1 < d2) 
            return -1;           // Neither val is NaN, thisVal is smaller 
        if (d1 > d2) 
            return 1;            // Neither val is NaN, thisVal is larger 
 
        // Cannot use doubleToRawLongBits because of possibility of NaNs. 
        long thisBits    = Double.doubleToLongBits(d1); 
        long anotherBits = Double.doubleToLongBits(d2); 
 
        return (thisBits == anotherBits ?  0 : // Values are equal 
                (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN) 
                 1));                          // (0.0, -0.0) or (NaN, !NaN) 
    } 
 
    /** use serialVersionUID from JDK 1.0.2 for interoperability */ 
    private static final long serialVersionUID = -9172774392245257468L; 
}

本文参考链接:https://www.cnblogs.com/yangyang12138/p/7398678.html