JDK8 ---- java.lang.Boolean理解

1 看源码的借鉴

1.1 看API文档

1.2 Boolean.getBoolean()和Boolean.parseBoolean()

public static void main(String[] args) {
        String tr = "true";
        System.out.println(Boolean.getBoolean(tr));
        System.setProperty(tr,"true");
        System.out.println(Boolean.getBoolean(tr));
        System.out.println("=======================");
        String fal = "false";
        System.out.println(Boolean.getBoolean(fal));
        System.setProperty(fal,"false");
        System.out.println(Boolean.getBoolean(fal));
        System.out.println("=======================");
        System.setProperty(fal,tr);
        System.setProperty(tr,fal);
        System.out.println(Boolean.getBoolean(tr));
        System.out.println(Boolean.getBoolean(fal));
        /*
        false
        true
        false
        false
        从结果中可以发现，当只有在系统中添加的相关的(key,value)后，才能够有true，且必须是key为"true"。
        或者说：
        如果key不为"true"，那么无论value是什么，都为false。
        如果key为"true"，那么无论结果是什么，都为true.
        */
    }

1.3 从JDK源码角度看Boolean

1.4 源码注释笔记

package java.lang;

/*
在一个对象中，Boolean类包装了基本类型boolean的值。
Boolean类型的对象，包含了一个boolean的简单字段。

 除此之外，Boolean类还提供了许多方法将boolean类型转为String类型。
 以及String类型转为boolean，
 */
public final class Boolean implements java.io.Serializable,
                                      Comparable<Boolean>
{
    /*
     与原始值对应的Boolean对象值true。
     */
    public static final Boolean TRUE = new Boolean(true);

    /*
     与原始值对应的Boolean对象值false。
     */
    public static final Boolean FALSE = new Boolean(false);

   
    @SuppressWarnings("unchecked")
    public static final Class<Boolean> TYPE = (Class<Boolean>) Class.getPrimitiveClass("boolean");

   
    private final boolean value;

    private static final long serialVersionUID = -3665804199014368530L;

    /*
     分配表示值参数的Boolean对象。

     使用此构造函数在很多时候是不适合的，除非需要创建一个新的实例，不然
     静态工厂方法valueOf()是较好的选择。

      它倾向于产生更为良好的空间和时间性能。
     */
    public Boolean(boolean value) {
        this.value = value;
    }

    /*
     如果字符串参数不为空且字符串参数为true，那么该为此Boolean对象赋予一个true值。
    
    否则就是为false。
    
     字符串转为Boolean对象。
     */
    public Boolean(String s) {
        this(parseBoolean(s));
    }

    /*
    解析该字符串参数称为一个boolean值。如果该string参数不为空
    且string.equalsIgnoreCase("true"),则返回true，否则就是false。
    主要的方法就是：String.equalsIgnoreCase();
     */
    public static boolean parseBoolean(String s) {
        return ((s != null) && s.equalsIgnoreCase("true"));
    }

   
    public boolean booleanValue() {
        return value;
    }

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

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

   
    public static String toString(boolean b) {
        return b ? "true" : "false";
    }

   
    public String toString() {
        return value ? "true" : "false";
    }

    /*
     * Returns a hash code for this {@code Boolean} object.
     为该Boolean对象返回一个hash code。
     */
    @Override
    public int hashCode() {
        return Boolean.hashCode(value);
    }

    /*
     返回一个boolean value的hash code，为了和Boolean.hashCode()兼容
     */
    public static int hashCode(boolean value) {
        return value ? 1231 : 1237;
    }

   /*
     当且仅当该对象不为null且是Boolean对象，表示于此对象相同的boolean值时，则返回true。
     */
    public boolean equals(Object obj) {
        if (obj instanceof Boolean) {
            return value == ((Boolean)obj).booleanValue();
        }
        return false;
    }

    // 该静态方法可以查看1.2进行理解
    public static boolean getBoolean(String name) {
        boolean result = false;
        try {
            result = parseBoolean(System.getProperty(name));
        } catch (IllegalArgumentException | NullPointerException e) {
        }
        return result;
    }

    /*
     将此Boolean实例和另一个Boolean实例进行比较。
     */
    public int compareTo(Boolean b) {
        return compare(this.value, b.value);
    }

    /*
     比较两个布尔值。 返回的值与
     Boolean.valueOf（x）.compareTo（Boolean.valueOf（y））返回的值相同。

     示例如下：
    public static void main(String[] args) {
        Boolean bool1 = Boolean.TRUE;
        Boolean bool2 = Boolean.FALSE;
        System.out.println(bool1.compareTo(bool2));
        System.out.println(bool1.compareTo(bool1));
        System.out.println(bool2.compareTo(bool1));
    }
    输出结果如下：
        1
        0
        -1
     */
    public static int compare(boolean x, boolean y) {
        return (x == y) ? 0 : (x ? 1 : -1);
    }

    /*
     返回将逻辑AND运算符应用于指定的布尔操作数的结果
     */
    public static boolean logicalAnd(boolean a, boolean b) {
        return a && b;
    }

    /*
     返回将逻辑OR运算符应用于指定的布尔操作数的结果
     */
    public static boolean logicalOr(boolean a, boolean b) {
        return a || b;
    }

    /*
    返回将逻辑XOR(异或)运算符应于指定的布尔操作数的结果。
    示例：

    public static void main(String[] args) {
        Boolean bool1 = Boolean.TRUE;
        Boolean bool2 = Boolean.FALSE;
        System.out.println(Boolean.logicalXor(bool1,bool1));
        System.out.println(Boolean.logicalXor(bool1,bool2));
        System.out.println(Boolean.logicalXor(bool2,bool2));
        
    }
    结果：
    false
    true
    false
     */
    public static boolean logicalXor(boolean a, boolean b) {
        return a ^ b;
    }
}