深入学习java源码之Boolean.hashCode()()与Boolean.compare()

深入学习java源码之Boolean.parseBoolean()与Boolean.getBoolean()

java的Comparable接口

Comparable接口是一个泛型接口。Java类库中：Byte，Short，Integer，Long，Float，Double，Character，BigTnteger，BigDecimal，Calendar，String及Data类都实现了Comparable接口。可以直接调用，对于没有实现的类，可以通过接口implements实现。

CompareTo方法

Java提供Comparable接口为我们解决比较两个对象的问题。 
接口中的cpmpareTo方法判断这个象相对于比较对象的顺序,小于返回负整数，等于返回0，大于返回正整数。

  System.out.println("a".compareTo("z"));//打印测试
  System.out.println("z".compareTo("a"));//打印测试
  System.out.println(new Integer(10).compareTo(new Integer(20)));//打印测试
  System.out.println(new Integer(20).compareTo(new Integer(10)));//打印测试
--------------------- 
-25
25
-1
1

public class Rectangular implements Comparable<Rectangular> {
double length, width;

public Rectangular(double length, double width) {
this.length = length;
this.width = width;
}

public double getArea() {
return length * width;
}

@Override
public int compareTo(Rectangular o) {//重写比较方法
if (getArea() > o.getArea()) {//面积比较
return 1;
} else if (getArea() < o.getArea()) {
return -1;
} else return 0;
}
}

System.out.println(new Rectangular(1,1).compareTo(new Rectangular(2,2)));
System.out.println(new Rectangular(3,3).compareTo(new Rectangular(2,2)));//打印测试

 

java的hashCode方法

很多地方都会利用到hash表来提高查找效率。在Java的Object类中有一个方法:

public native int hashCode();

该方法返回一个int类型的数值，并且是本地方法，因此在Object类中并没有给出具体的实现。

对于包含容器类型的程序设计语言来说，基本上都会涉及到hashCode。在Java中也一样，hashCode方法的主要作用是为了配合基于散列的集合一起正常运行，这样的散列集合包括HashSet、HashMap以及HashTable。

　　为什么这么说呢？考虑一种情况，当向集合中插入对象时，如何判别在集合中是否已经存在该对象了？（注意：集合中不允许重复的元素存在）

　　也许大多数人都会想到调用equals方法来逐个进行比较，这个方法确实可行。但是如果集合中已经存在一万条数据或者更多的数据，如果采用equals方法去逐一比较，效率必然是一个问题。此时hashCode方法的作用就体现出来了，当集合要添加新的对象时，先调用这个对象的hashCode方法，得到对应的hashcode值，实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值，如果table中没有该hashcode值，它就可以直接存进去，不用再进行任何比较了；如果存在该hashcode值， 就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址，所以这里存在一个冲突解决的问题，这样一来实际调用equals方法的次数就大大降低了，说通俗一点：Java中的hashCode方法就是根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。

因此有人会说，可以直接根据hashcode值判断两个对象是否相等吗？肯定是不可以的，因为不同的对象可能会生成相同的hashcode值。虽然不能根据hashcode值判断两个对象是否相等，但是可以直接根据hashcode值判断两个对象不等，如果两个对象的hashcode值不等，则必定是两个不同的对象。如果要判断两个对象是否真正相等，必须通过equals方法。

也就是说对于两个对象，如果调用equals方法得到的结果为true，则两个对象的hashcode值必定相等；

如果equals方法得到的结果为false，则两个对象的hashcode值不一定不同；

如果两个对象的hashcode值不等，则equals方法得到的结果必定为false；

如果两个对象的hashcode值相等，则equals方法得到的结果未知。

重写equals方法的同时，必须重写hashCode方法，默认情况下，hashCode方法是将对象的存储地址进行映射。

• 在程序执行期间，只要equals方法的比较操作用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法必须始终如一地返回同一个整数。
• 如果两个对象根据equals方法比较是相等的，那么调用两个对象的hashCode方法必须返回相同的整数结果。
• 如果两个对象根据equals方法比较是不等的，则hashCode方法不一定得返回不同的整数。

　“设计hashCode()时最重要的因素就是：无论何时，对同一个对象调用hashCode()都应该产生同样的值。如果在讲一个对象用put()添加进HashMap时产生一个hashCdoe值，而用get()取出时却产生了另一个hashCode值，那么就无法获取该对象了。所以如果你的hashCode方法依赖于对象中易变的数据，用户就要当心了，因为此数据发生变化时，hashCode()方法就会生成一个不同的散列码”。

 

静态方法

Modifier and Type	Method and Description
boolean	booleanValue() 将此 Boolean对象的值作为布尔基元返回。
static int	compare(boolean x, boolean y) 比较两个 boolean值。
int	compareTo(Boolean b) 将此 Boolean实例与另一个实例进行比较。
boolean	equals(Object obj) 返回 true当且仅当参数不是 null ，并且是一个 Boolean对象，表示与此对象相同的 boolean值。
static boolean	getBoolean(String name) 返回 true当且仅当由参数命名的系统属性存在且等于字符串 "true" 。
int	hashCode() 返回此 Boolean对象的哈希码。
static int	hashCode(boolean value) 返回一个boolean值的哈希码; 兼容Boolean.hashCode() 。
static boolean	logicalAnd(boolean a, boolean b) 返回将逻辑AND运算符应用于指定的 boolean操作数的结果。
static boolean	logicalOr(boolean a, boolean b) 返回将逻辑OR运算符应用于指定的 boolean操作数的结果。
static boolean	logicalXor(boolean a, boolean b) 返回将逻辑XOR运算符应用于指定的 boolean操作数的结果。
static boolean	parseBoolean(String s) 将字符串参数解析为布尔值。
String	toString() 返回一个 String此布尔值的 String对象。
static String	toString(boolean b) 返回一个 String指定布尔值的 String对象。
static Boolean	valueOf(boolean b) 返回一个 Boolean指定的 boolean值的 Boolean实例。
static Boolean	valueOf(String s) 返回一个 Boolean ，其值由指定的字符串表示。

接口方法

Modifier and Type	Method and Description
boolean	booleanValue() 将此 Boolean对象的值作为布尔基元返回。
int	compareTo(Boolean b) 将此 Boolean实例与另一个实例进行比较。
boolean	equals(Object obj) 返回 true当且仅当参数不是 null ，并且是一个 Boolean对象，表示与此对象相同的 boolean值。
int	hashCode() 返回此 Boolean对象的哈希码。
String	toString() 返回一个 String此布尔值的 String对象。

 

java源码

public final class Boolean implements java.io.Serializable,
                                      Comparable<Boolean>
{

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;

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"));
    }
    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";
    }
    @Override
    public int hashCode() {
        return Boolean.hashCode(value);
    }
    public static int hashCode(boolean value) {
        return value ? 1231 : 1237;
    }
    public boolean equals(Object obj) {
        if (obj instanceof Boolean) {
            return value == ((Boolean)obj).booleanValue();
        }
        return false;
    }
    public static boolean getBoolean(String name) {
        boolean result = false;
        try {
            result = parseBoolean(System.getProperty(name));
        } catch (IllegalArgumentException | NullPointerException e) {
        }
        return result;
    }
    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);
    }
    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;
    }
}

package java.lang;
import java.util.*;


public interface Comparable<T> {

    public int compareTo(T o);
}