Set.contains(Object)和Set.add(Object)的用法浅谈

之前写了一篇关于List.contains(Object)的用法，这次梳理一下他的兄弟Set集合contains的用法。
问题场景：同样是在写业务侧代码的时候，我们存在这种场景，筛选出不重复的对象，不想用List中的contains判断，而是直接用java给我们的集合Set，因为Set的定义就是承载不重复的数据，因为它的底层原理是通过HashMap来实现的，Set中的每个对象就是HashMap中的key值。

Object
原先设想，两个属性完全相同的对象，应该属于同一对象，添加到Set数组中，应该只会添加一个对象，真的是这样吗？看代码：

public class Test1 {
    public static void main(String args[])
    {
        MailSenderFactory mail1 = new MailSenderFactory();
        MailSenderFactory mail2 = new MailSenderFactory();
        mail1.setId("1");
        mail1.setName("wdw");
        mail2.setId("1");
        mail2.setName("wdw");

        // 校验set<Object>
        Set<MailSenderFactory> mailSet = new HashSet<MailSenderFactory>();
        mailSet.add(mail1);
        System.out.println(mailSet.contains(mail2));
        mailSet.add(mail2);
        System.out.println(mailSet);

        System.out.println("objAddress：" + mail1.hashCode());
        System.out.println("objAddress：" + mail2.hashCode());
        System.out.println("####");
        System.out.println("objAddress：" + System.identityHashCode(mail1));
        System.out.println("objAddress：" + System.identityHashCode(mail2));     
    }
}

这里我创建了两个对象，属性值id和name完全相同，但是打印结果却是：

图1

问题1：实际上数组中添加了业务理解上相同的两个对象，应该只添加一个；
问题2：添加完mail1对象后，判断set数组是否包含mail2，我们希望是包含，但实际上程序输出的结果却是false，不包含

解答1：看下set.add()的源码，
1）调用的是HashSet.class的add方法

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

2）然后调用HashMap.class中的put方法，先hash，再putVal

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

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;
    }

注意第二段代码的hash方法，key.hashCode()调用的是Object.class中的hash，这里对象的hashcode没有重写，而是直接使用的是系统identityHashCode，这就是为什么用不同方法打印的对象地址值是一样的，见图1

* @return  a hash code value for this object.
     * @see     java.lang.Object#equals(java.lang.Object)
     * @see     *java.lang.System#identityHashCode*
     */
    public native int hashCode();

这是一个伏笔，大家记住了，不同的对象生成的hashcode不同，也就是引用的地址不同；
我们再返回头看第三段代码putVal方法：
tab我们可以看做是map，p可以看做是entry(hashmap中的一种结构体)，第二个if中的条件p = tab[i = (n - 1) & hash]是在判断添加对象的hash地址是否能够映射到map中的entry，如果映射结果为null，需要创建新的Node（entry）；而由于，我们添加的第二个对象mail2，虽然属性值与mail1一样，但是他的引用地址与mail1不同，映射的index（(n - 1) & hash）一般情况也不会与mail相同，因此，仍然能够添加到set数组；
如果我们创建的第二个对象mail2的hash地址映射的结果不巧与mail1冲突（相同），那我们就要判断key.equals(k))，这里比较的是对象的引用，不同对象，引用地址一定不同，因此还不是同一对象，还是要添加到set数组；
这就解释了第一个问题。

解答2：
看下set.contains()的源码，
1）调用hashMap.class中的containsKey

public boolean contains(Object o) {
        return map.containsKey(o);
    }

public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }

2）再调用getNode：

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

这段代码看第一个if中的第三个判断条件(first = tab[(n - 1) & hash]) != null，返回null；
如果映射的index相同，我们在做第二个if中的key.equals(k)这个判断，原理同上，返回null。

总结
综上所述，通过set过滤相同的Object需要两步，1）通过hashcode映射成的index要相同；2）equals要相同；这两者缺一不可，一个条件不成立，就不能说明Object相同。
因此如果想使用set来过滤相同的对象（Object），就要对存储对象的hashcode和equels方法进行重写，

@Override
    public int hashCode()
    {
        return this.name.hashCode() + Integer.valueOf(id) * 31;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (obj instanceof MailSenderFactory)
        {
            MailSenderFactory mail = (MailSenderFactory) obj;
            if (mail.getName().equals(this.name) && mail.getId().equals(this.id))
            {
                return true;
            }
        }
        return false;
    }

好了，今天就写到这里，如果有什么问题，欢迎大家批评指正，一起学习探讨。