【Java源码】理解equals/hashCode()源码并用HashSet实现对象去重

Set集合具有去重复的特性，当元素为对象时却不凑效

为什么呢，看一下JDK1.8中HashSet的数据结构：

/**
 * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
 * default initial capacity (16) and load factor (0.75).
 */
 public HashSet() {
    map = new HashMap<>();
 }

可见new HashSet()操作实际上是new HashMap<>()，可见底层是以HashMap来实现的

private transient HashMap<E,Object> map;

// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();

HashSet.add方法：

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

HashMap.add方法：

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
 
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

可以从上面的加粗字段看出，判断插入的key是否存在，要判断两点
①hash值是否相同②对应的值是否相同，前者要看hashCode()方法，后者要看equal()方法。

下面我们来探索一下基本的数据类型和自定义类类型在计算hashCode和equal的区别，看一下如下代码：

@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
/*使用了lombok不需编写get/set方法*/
public class HighTimeBase {
    /**
     * 开始时间 hh:mm:ss
     */
    private String startTime;
    /**
     * 结束时间 hh:mm:ss
     */
    private String endTime;

	public static void main(String[] args) {
        HighTimeBase obj1 = new HighTimeBase("10:00:00", "11:11:11");
        HighTimeBase obj2 = new HighTimeBase("11:55:56", "12:55:56");
        HighTimeBase obj3 = new HighTimeBase("10:00:00", "11:11:11");

        Integer num1 = 2;
        Integer num2 = 2;

        String str1 = new String("abc");
        String str2 = new String("abc");

        // 测试 equals()
        System.out.println(num1.equals(num2));// 比较数字
        System.out.println(str1.equals(str2));// 比较字符串
        System.out.println(obj1.equals(obj3));// 比较对象
        System.out.println("----------------------");

        // 测试 hashCode()
        System.out.println(num1.hashCode() == num2.hashCode());// 比较数字
        System.out.println(str1.hashCode() == str2.hashCode());// 比较字符串
        System.out.println(obj1.hashCode() == obj2.hashCode());// 比较对象
        System.out.println("----------------------");
        
        List<HighTimeBase> highTimeBaseList = new ArrayList<>();
        highTimeBaseList.add(obj1);
        highTimeBaseList.add(obj2);
        highTimeBaseList.add(obj3);
        for (HighTimeBase item : highTimeBaseList) {
            System.out.println(item);
        }
    }
}

测试结果
在这里插入图片描述

equals方法

java.lang.Integer继承Object`类下重写的equals()：两个对象对应的值一致则返回true。

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

java.lang.String继承Object类下重写的equals()类下重写的equals():

public boolean equals(Object anObject) {
    if (this == anObject) {//同一个对象，必定是一致的
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {//对比每一个字符
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;//anObject不是String实例，那么返回false
}

java.lang.Object下的equals()：两个对象的引用是否一致，即两个的对象是否是同一个。

可见一个类要是没有重写Object类的equals()方法,那默认继承的就是Object()方法,即使用内存地址来判断是否相等

public boolean equals(Object obj) {
    return (this == obj);
}

可见对于java.lang.Object.equals()来讲，两个new出来的对象肯定是不一致的，那么在HashMap数据结构中不会被判定成相同的对象（尽管值相同）。下面再看看hashCode的源码：

HashCode方法

java.lang.Integer继承Object类重写的hashCode()方法:

@Override
public int hashCode() {
    return Integer.hashCode(value);
}
 
public static int hashCode(int value) {
    return value;
}

java.lang.String继承Object类重写的hashCode()方法:

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
 
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

java.lang.Object类下的hashCode():

//Object的hashcode是使用本地方法，返回的是该对象的内存地址
public native int hashCode();

JDK8的默认hashCode的计算方法是通过和当前线程有关的一个随机数+三个确定值，运用Marsaglia’s xorshift schema随机数算法得到的一个随机数。

因此，以上可以看到Integer和String也都是根据具体的value值来计算hashCode，那么尽管两个引用不同但是值相同的对象，依然是相等的，但是Object则不同了。

String重写的hashcode为什么是31?

这里理解就是将字符串的char数组中的每个位置数值*31再叠加后并返回，这样对于没有不同的字符串，返回的hashcode值肯定不一样。但这里的31，是什么鬼呢，为什么偏偏是31呢，网上查了一下如下：

之所以使用 31，是因为他是一个奇素数。如果乘数是偶数，并且乘法溢出的话，信息就会丢失，因为与2相乘等价于移位运算（低位补0）。
使用素数的好处并不很明显，但是习惯上使用素数来计算散列结果。
31 有个很好的性能，即用移位和减法来代替乘法，可以得到更好的性能: 31*i == (i << 5)- i，现代的 VM 可以自动完成这种优化。这个公式可以很简单的推导出来。
说白了性能，性能，性能。就是为了性能才设置的，具体涉及到数学理论。。。

处理方式

@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class HighTimeBase {
    /**开始时间 hh:mm:ss*/
    private String startTime;
    /**结束时间 hh:mm:ss*/
    private String endTime;

    /**
     * 重新equals方法,如果对象类型是HighTimeBase,先比较hashcode，一致的场合再比较每个属性的值
     * @param object
     * @return
     */
       @Override
    public boolean equals (Object object) {
        //　比较的对象为null,判断为不相等
        if (object == null) {
            return false;
        }

        // 如果内存地址相同,判断为相等
        if(this == object) {
            return false;
        }

        // 如果判断的对象属于 HighTimeBase 类型的
        if (object instanceof HighTimeBase) {
            HighTimeBase highTimeBase = (HighTimeBase) object;

            //如果所有的属性值都相同,判断为同一个对象
            if (highTimeBase.startTime.equals(this.startTime) && highTimeBase.endTime.equals(this.endTime)) {
                return  true;
            }
        }
        return false;
    }

    /**
     * 重新hashCode方法,，返回的hashCode不一样才再去比较每个属性的值
     *
     * @return
     */
    @Override
    public int hashCode() {
        StringBuilder sb = new StringBuilder();
        sb.append(startTime);
        sb.append(endTime);
        char[] charArr = sb.toString().toCharArray();
        int hash = 0;
        for(char c : charArr) {
            hash = hash * 31 + c;
        }
        return hash;
    }
    
    public static void main(String[] args) {
        HighTimeBase obj1 = new HighTimeBase("10:00:00", "11:11:11");
        HighTimeBase obj2 = new HighTimeBase("11:55:56", "12:55:56");
        HighTimeBase obj3 = new HighTimeBase("10:00:00", "11:11:11");

        System.out.println(obj1.hashCode() == obj3.hashCode());// 比较对象
        System.out.println("----------------------");

        List<HighTimeBase> highTimeBaseList = new ArrayList<>();
        highTimeBaseList.add(obj1);
        highTimeBaseList.add(obj2);
        highTimeBaseList.add(obj3);

        //对象集合去重
        Set<HighTimeBase> highTimeBaseSet = new HashSet<>();
        highTimeBaseSet.addAll(highTimeBaseList);

        for (HighTimeBase item : highTimeBaseSet) {
            System.out.println(item);
        }
    }
}

总结

在阿里巴巴Java开发是手册的集合处理中需要强制遵循如下规则：

只要重写equals，就必须重写hashCode
因为Set存储的是不重复的对象，依据hashCode和equals进行判断，所以Set存储的对象必须重写这两个方法。
如果自定义对象做为Map的键，那么必须重写hashCode和equals。如: String重写了hashCode和equals方法，所以我们可以非常愉快的使用String对象作为key来使用。

相关文章
https://blog.csdn.net/weixin_38426554/article/details/96424995
https://www.cnblogs.com/weilu2/p/java_hashcode_equals.html

oollXianluo

发布了62 篇原创文章 · 获赞 109 · 访问量 5313

私信关注