JDK版本

1. jdk1.8

Boolean

Boolean主要是对基本类型boolean的包装，Boolean是一个Immutable的类

       public class BooleanTest {
   @Test
   public void testCreate() {
       boolean flag = Boolean.getBoolean("true");
       System.out.println(flag);// FALSE 
       flag = Boolean.getBoolean(null);
       System.out.println(flag);//false
       flag = Boolean.parseBoolean("true");
       System.out.println(flag);//true
       flag = Boolean.valueOf("true");
       System.out.println(flag);//true
       System.out.println(Boolean.TRUE);//true
       System.out.println(Boolean.FALSE);//false
       System.out.println(Boolean.TYPE); //boolean
   }
}  

属性和 构造函数

属性和构造函数： TRUE 和 FALSE 这两个变量在Class Loader装载时就被实例化，并且申明为final，不能再指向其他实例。提供这两个静态变量是为了让开发者直接使用这两个变量而不是每次都new一个Boolean，这样既节省内存又避免了创建一个新实例的时间开销.因此使用 Boolean b = Boolean.TRUE 比使用 Boolean b = new Boolean(true) 要好的多

 public static final Boolean TRUE = new Boolean(true);
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;
/** use serialVersionUID from JDK 1.0.2 for interoperability */private static final long serialVersionUID = -3665804199014368530L;
public Boolean(boolean value) {
   this.value = value;
}
public Boolean(String s) {
   this(parseBoolean(s));
}
public static boolean parseBoolean(String s) {
   return ((s != null) && s.equalsIgnoreCase("true"));
}  

单个的boolean 类型变量在编译的时候是使用的int 类型, true 用 1 表示，false 用 0 表示

 boolean a=true;//这个a在JVM中占4个字节即：32位。  

boolean 类型的数组时，在编译的时候是作为byte array来编译的所以boolean 数组里面的每一个元件占一个字节

 boolean[] b = new boolean[10];//数组时，每一个boolean在JVM中占一个字节  

验证

 public class AA {
   public static void main(String[] args) {
       boolean a = true;
       boolean[] b = new boolean[10];
       b[0] = true;
       System.out.println(a);
   }
}
main方法的字节码
========  对应 boolean a = true; ========  
iconst_1                         //Push int constant
istore_1                         //Store int into local variable
======== 对应  boolean[] b = new boolean[10]; =======  
bipush 10                            //Push byte
newarray 4 (boolean)  //Create new array
astore_2     //Store reference into local variable
aload_2      //Load reference from local variable
========  对应 b[0] = true ========    
iconst_0  //Push int constant
iconst_1  //Push int constant
bastore  //Store into byte or boolean array
========   System.out.println(a) ========      
getstatic #2 < java /lang/System.out>
iload_1  //从本地变量加载int
invokevirtual #3 <java/io/PrintStream.println>
return  

工厂方法

如果遇到需要使用构造方法创建Boolean，则推荐使用静态工厂方法valueOf,可以避免创建新的实例

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

获取系统属性的Boolean

getBoolean:如果不为true，无论是异常、null、还是false都返回false。

 public static boolean getBoolean(String name) {
   boolean result = false;
   try {
       result = parseBoolean(System.getProperty(name));
   } catch (IllegalArgumentException | NullPointerException e) {
   }
   return result;
}  

逻辑运算

逻辑运算

 public static boolean logicalAnd(boolean a, boolean b) {
   return a && b;
}
public static boolean logicalOr(boolean a, boolean b) {
   return a || b;
}
public static boolean logicalXor(boolean a, boolean b) {
   return a ^ b;
}  

其他方法

toString方法

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

compareTo

 public int compareTo(Boolean b) {
   return compare(this.value, b.value);
}
public static int compare(boolean x, boolean y) {
   return (x == y) ? 0 : (x ? 1 : -1);
}  

equals方法:因为(null instanceof AnyType)永远是false,所以使用equals方法不需要判断是否为空

 public boolean equals(Object obj) {
   if (obj instanceof Boolean) {
       return value == ((Boolean)obj).booleanValue();
   }
   return false;
}
public boolean booleanValue() {
   return value;
}  

hashcode 方法

 @Override
public int hashCode() {
   return Boolean.hashCode(value);
}
//true返回1231，false返回1237
public static int hashCode(boolean value) {
   return value ? 1231 : 1237;
}  

为什么hashcode返回的1231和1237？

1231和1237是两个足够大的质数，写成任意两个足够大的质数都是可以的

为什么一定要是质数？

1000%8 与2000 % 8是相同的

1000 % 10与2000 % 10是相同的

1000 % 20 与2000 % 20是相同的