Integer类源码阅读（二）

package java.lang;    
import java.util.Properties;    
public final class Integer extends Number implements Comparable<Integer> {
    //Integer的值
    private final int value;
    
    public Integer(int value) {
        this.value = value;
    }
    //由字符串来初始化Integer
    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(); //比较两个Integer的int值
        }
        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;
    }
    //返回系统属性的Integer值表示，nm表示系统属性，val表示默认值
    public static Integer getInteger(String nm, Integer val) {
        String v = null;
        try {
            v = System.getProperty(nm); //获取nm指定的属性
        } catch (IllegalArgumentException e) {
        } catch (NullPointerException e) {
        }
        if (v != null) {
            try {
                return Integer.decode(v); //将属性v转化为Integer表示
            } catch (NumberFormatException e) {
            }
        }
        return val;
    }
    //将字符串解码为Integer
    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.
            //处理为Integer的最小值的情况，该处会再次抛出异常
            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); //比较x,y的大小，x<y返回-1，x=y返回0，x>y返回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);
    }
}