[java]Set集合刪除元素失效問題

引子

記一次在工做當中，有這樣一個業務場景：

​ 在經過接口返回前，須要爲一個set中的全部元素賦值，而後剔除掉一些不符合條件的元素，最後返回。代碼結構大概以下：

代碼

Set<Item> sets = Sets.newHashSet();
sets.addAll(items);
...
setValue(sets) ;

//剔除sets中不符合條件的元素
**sets.removeIf(Predicate filter);**

//爲set中的元素設置屬性
private setValue(Set<Item> sets){
    for(Item:item sets){
        ...
    }
}

看似是一段clean code，邏輯清晰，實則蘊藏殺機；你們大概一眼就能看出其中玄機，其中的removeif壓根就不起做用啊，但是菜如狗的我還沒發現其中一二，還在慢慢的debug，寫單元測試，並單純的覺得是編譯的問題...終於一位同事在review以後，一語點醒我："removeIf 是如何找到你要刪除的元素的呢？"

緣由

終於，我在查看了set集合removeIf與addAll的原理之後，頓悟了，主要有四個關鍵點：

1. HashSet底層實際上就是一個HashMap, 節選一段hashSet的構造方法就能發現，其中key爲要添加的元素，value爲Present，以下：

   private static final Object PRESENT = new Object();
   
       public HashSet() {
           map = new HashMap<>();
       }

2. 在向set中添加元素調用addAll方法時，實際上也是循環調用set的add方法，而實際上也是調用map的put方法。

   public boolean addAll(Collection<? extends E> c) {
           boolean modified = false;
           for (E e : c)
               if (add(e))
                   modified = true;
           return modified;
       }
   
   public boolean add(E e) {
           return map.put(e, PRESENT)==null;
    }

3. set在執行removeIf操做時，實際上調用的是 iterator的remove操做,而collection繼承了iterator，set繼承了collection，底層經過hashmap實現，（@w@～ 有點繞）， 實際上就是調用的map的remove方法，以下：

   default boolean removeIf(Predicate<? super E> filter) {
           Objects.requireNonNull(filter);
           boolean removed = false;
           final Iterator<E> each = iterator();
           while (each.hasNext()) {
               if (filter.test(each.next())) {
                   each.remove();
                   removed = true;
               }
           }
           return removed;
       }

4. 如今咱們瞭解到，set在添加或者是刪除元素均是調用的map的對應的方法，而hashMap是經過數據+鏈表+紅黑樹實現的,可是map是如何找到這些元素，並進行相應的添加或刪除操做呢？以下put方法，

   首先調用了hash方法計算key的hash值，在hash方法則調用了key的hashCode方法以及移位以及邏輯異或運算。

   而後又調用了putVal方法，在該方法中咱們瞭解到hashMap主要是經過key的該hash值進行尋找元素的插入位置的，若已存在，值覆蓋，不然插入，其中的其餘方法這裏再也不展開。

   //首先是put方法的實現
    public V put(K key, V value) {
           return putVal(hash(key), key, value, false, true);
    }
   //hash方法
   static final int hash(Object key) {
           int h;
           return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
       }
   //put又調用的putVal方法
   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;
       }

   接着是remove方法源碼以下，咱們發現，在remove方法中，仍然首先調用hash方法計算key的hash值，而後調用removeNode進行刪除操做，這裏在刪除時移動其餘元素的方法再也不展開，咱們能夠知道，remove方法仍然是經過key的hash來查詢要刪除的元素的。

   public V remove(Object key) {
           Node<K,V> e;
           return (e = removeNode(hash(key), key, null, false, true)) == null ?
               null : e.value;
       }
   
       /**

*
     * @param hash hash for key
     * @param key the key
     * @param value the value to match if matchValue, else ignored
     * @param matchValue if true only remove if value is equal
     * @param movable if false do not move other nodes while removing
     * @return the node, or null if none
     */
    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }
```

經過分析上述的removeIf與addAll源碼可知，底層均調用的map的put與remove方法。一樣的，set在add元素時，首先會計算元素的hash值，來尋找元素的插入位置；
在刪除元素時，一樣會從新計算元素的hash值來查詢要刪除的元素；而hash方法主要是經過元素的hashCode方法來計算的，那麼出現刪除失效的問題必定是與hahsCode方法有關的，我查了下該類，果真，hashCode方法被重寫了........因此在add與remove時，對應元素的hashCode不一樣，由於這之間我爲元素賦了值。

也就是說該問題是由 元素在add進集合時hashCode與remove時的hashcode不一致形成的。
....固然，能找到緣由仍是很開心的～

解決辦法

1. 最笨的，再新建一個集合，遍歷，把符合條件的元素留下
2. 挪一下方法的位置，不要在add與remove之間爲相應元素屬性複製，這固然要看你本身的業務場景與hashCode的重寫邏輯咯
3. 重寫hashcode方法與equals方法。