hashCode()方法以及集合中Set的一些总结

一、前言

本篇文章没有什么主题，就是一些零散点的总结。
周末没事看了几道蚂蚁金服的面试题，其中有好几道都是特别简单的，基础性的题目，就是我们平时用到的，但是发现要是完全说出来还是有一些不清楚的地方，所以小小的总结一下。

二、hashCode()方法理解

提到hashCode()必然会涉及equals()方法，二者是紧密相连的，其实面试中被问到这方面往往是考察集合存储对象判断相等的问题。

比如有如下Person类：

public class Person {

    private int age;
    private String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }
}

很简单吧，我这里只重写了equals方法，如果我们以Person类对象作为key存储在HashMap中，如下：

HashMap map = new HashMap();
map.put(new Person(45,"lisi"),"123");
System.out.println(map.get(new Person(45,"lisi")));

试想一下能正常取出"lisi"值吗？对HashMap源码看过的同学肯定知道取不出来，打印如下：

null

HashMap在取数据的时候会检查对应的key是否已经存储过，这个比较简单来说就是比较key的hashcode()值以及equals()是否相等的比较，只有二者均相同才会认为已经存储过，对于上述Person类我们只重写了equals方法，对于hashcode()方法默认调用的是Object类中的hashcode()方法：

    public int hashCode() {
        return identityHashCode(this);
    }

不同对象会生成不同的hash值，所以严格来说hashcode()与equals()方法我们最好同时重写，否则与集合类结合使用的时候会产生问题，改造Person类添加如下hashcode()方法：

    @Override
    public int hashCode() {
        return Objects.hash(age, name);//根据类中属性生成对应hash值
    }

这样就可以正常获取对应值了。

HashMap中比较元素是否相同是根据Key的hashcode值以及equals来判断是否相同的。

三、Set集合常用类相关问题

Set集合常用与存储不重复的数据，也就是集合中数据都不相等，但是不同具体实现类判断是否相等是不一样，这也是面试中会问到的问题，比如TreeSet是怎么判断元素是否相同的？HashSet是怎么判断的？

其实稍微看一下源码就明白了，Set具体实现类都是依靠对应map来实现的：

• HashSet底层依靠HashMap来实现
• TreeSet底层依靠TreeMap来实现
• LinkedHashSet底层依靠LinkedHashMap来实现

HashSet

看一下HashSet源码吧：

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;

    private transient HashMap<E,Object> map;

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

    public HashSet() {
        map = new HashMap<>();
    }

    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }

    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

    public int size() {
        return map.size();
    }

    public boolean isEmpty() {
        return map.isEmpty();
    }

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

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

    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

    public void clear() {
        map.clear();
    }

这里只列出了部分方法，不过已经足够了，几个构造方法也就是初始化HashMap，其余的方法也都是调用HashMap对应的方法，所以你要是理解了HashMap那HashSet几秒钟就全都懂了，不理解HashMap请转到：

Android版数据结构与算法(四):基于哈希表实现HashMap核心源码彻底分析

我们在调用add(E e)方法的时候，key就是e，而value永远是PRESENT，也就是Object()对象了。

这里注意一下：

    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

这个构造方法是给LinkedHashSet调用的，我们无法使用，没有public修饰。

所以要是问你HashSet如何判断元素重复的，也就是和HashMap一样通过hashcode()与equals()方法来判断。

LinkedHashSet

接下来看下LinkedHashSet源码：

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {

    private static final long serialVersionUID = -2851667679971038690L;

    public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);
    }

    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }

    public LinkedHashSet() {
        super(16, .75f, true);
    }

    public LinkedHashSet(Collection<? extends E> c) {
        super(Math.max(2*c.size(), 11), .75f, true);
        addAll(c);
    }

    @Override
    public Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.DISTINCT | Spliterator.ORDERED);
    }
}

就是那么简短，LinkedHashSet继承HashSet，初始化调用的就是HashSet中三个参数的构造函数，上面已经提到，也就map初始为LinkedHashMap，如果你对LinkedHashMap完全理解，那么这里就十分简单了，如果不理解LinkedHashMap，请转到：

Android版数据结构与算法(五):LinkedHashMap核心源码彻底分析

总结一句话：LinkedHashSet是数据无重复并基于存入数据顺序排序的集合，数据重复判断的依据依然是hashcode()与equals()方法来判断。

TreeMap

同样看一下TreeMap中部分源码，构造部分：

    private transient NavigableMap<E,Object> m;

    private static final Object PRESENT = new Object();

    TreeSet(NavigableMap<E,Object> m) {
        this.m = m;
    }

    public TreeSet() {
        this(new TreeMap<E,Object>());
    }

    public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }

看到了吧，构造时我们可以自己指定一个NavigableMap，如不指定则默认为TreeMap，所以TreeSet底层实现为TreeMap，加入数据的时候value同样永远是Object：

    public boolean add(E e) {
        return m.put(e, PRESENT)==null;//private static final Object PRESENT = new Object();
    }

TreeMap如不熟悉请转到：

红黑树与TreeMap

TreeMap是怎么比较数据是否相等的呢？怎么排序的呢？这里我们就要查看一下TreeMap中的put方法源码了：

    public V put(K key, V value) {
        TreeMapEntry<K,V> t = root;
        if (t == null) {
            // BEGIN Android-changed: Work around buggy comparators. http://b/34084348
            // We could just call compare(key, key) for its side effect of checking the type and
            // nullness of the input key. However, several applications seem to have written comparators
            // that only expect to be called on elements that aren't equal to each other (after
            // making assumptions about the domain of the map). Clearly, such comparators are bogus
            // because get() would never work, but TreeSets are frequently used for sorting a set
            // of distinct elements.
            //
            // As a temporary work around, we perform the null & instanceof checks by hand so that
            // we can guarantee that elements are never compared against themselves.
            //
            // **** THIS CHANGE WILL BE REVERTED IN A FUTURE ANDROID RELEASE ****
            //
            // Upstream code was:
            // compare(key, key); // type (and possibly null) check
            if (comparator != null) {
                if (key == null) {
                    comparator.compare(key, key);
                }
            } else {
                if (key == null) {
                    throw new NullPointerException("key == null");
                } else if (!(key instanceof Comparable)) {
                    throw new ClassCastException(
                            "Cannot cast" + key.getClass().getName() + " to Comparable.");
                }
            }
            // END Android-changed: Work around buggy comparators. http://b/34084348
            root = new TreeMapEntry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        TreeMapEntry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        TreeMapEntry<K,V> e = new TreeMapEntry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

通过查看put方法逻辑，初始化TreeMap可以自己指定比较器comparator，如果我们指定了comparator那么数据的比较优先使用指定的comparator，是否存入null也由我们自己的比较器comparator决定，如果没指定那么存入的元素必须实现Comparable接口，否则抛出异常。

回到TreeSet，也就是TreeSet比较元素是否相等时如果我们指定了comparator那么就根据其compare方法返回值来比较，0代表相等，如果没指定那么就需要数据自己实现Comparable接口，是否相等根据compareTo返回值决定，0代表相等。

TreeSet也能保证数据的有序性，与LinkedHashSet基于插入顺序排序不同，TreeSet排序是根据元素比较来排序的。

蚂蚁金服有道面试题是：TreeSet存入数据有什么要求？看完上面你知道怎么回答了吗？很简单，如果我们没指定TreeSet集合的比较器那么插入的数据需要实现Comparable接口用来比较元素是否相等以及排序用。

好了，以上就是Set集合的一些总结。

四、HashMap线程不安全的体现

fail-fast机制

我们知道大部分集合类中在用迭代器迭代过程中要删除集合中元素最好用迭代器的删除方法，否则会发生并发异常，如下：

HashMap map = new HashMap();
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"4");

        Set entrySet = map.entrySet();
        Iterator<Map.Entry> iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry entry = iterator.next();
            if (entry.getKey().equals(2)){
                map.remove(entry.getKey());//调用集合类本身的删除方法
            }
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }

运行程序如下：

1--->1
2--->2
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.HashMap$HashIterator.nextNode(HashMap.java:1437)
	at java.util.HashMap$EntryIterator.next(HashMap.java:1471)
	at java.util.HashMap$EntryIterator.next(HashMap.java:1469)
	at com.wanglei55.mjavalib.myClass.main(myClass.java:173)

至于产生问题原因这里我就不细说了，很基础的。

改为如下用迭代器删除就可以了：

        HashMap map = new HashMap();
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"4");

        Set entrySet = map.entrySet();
        Iterator<Map.Entry> iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry entry = iterator.next();
            if (entry.getKey().equals(2)){
                iterator.remove();//改为迭代器删除
            }
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }

这里我们看一下迭代器怎么删除的：

public final void remove() {
            Node<K,V> p = current;
            if (p == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            current = null;
            K key = p.key;
           // 迭代器调用的也是集合本身的删除方法核心逻辑，我们知道集合本身删除会改变modCount值，但是迭代器删除后紧接着重新赋值expectedModCount = modCount，这样就不会产生并发异常
            removeNode(hash(key), key, null, false, false);
            expectedModCount = modCount;
        }

上面是在单线程下，如果多线程呢？我们看一下，改造代码如下：

final HashMap map = new HashMap();
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"4");

        Thread t1 = new Thread(){
            @Override
            public void run() {
                Set entrySet = map.entrySet();
                Iterator<Map.Entry> iterator = entrySet.iterator();
                while (iterator.hasNext()){
                    Map.Entry entry = iterator.next();
                    if (entry.getKey().equals(2)){
                        iterator.remove();//改为迭代器删除
                    }
                }
            }
        };

        Thread t2 = new Thread(){
            @Override
            public void run() {
                Set entrySet = map.entrySet();
                Iterator<Map.Entry> iterator = entrySet.iterator();
                while (iterator.hasNext()){
                    Map.Entry entry = iterator.next();
                    System.out.println(entry.getKey()+"--->"+entry.getValue());
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        t1.start();
        t2.start();

运行程序，有时依然会报并发异常：

1--->1
Exception in thread "Thread-1" java.util.ConcurrentModificationException
	at java.util.HashMap$HashIterator.nextNode(HashMap.java:1437)
	at java.util.HashMap$EntryIterator.next(HashMap.java:1471)
	at java.util.HashMap$EntryIterator.next(HashMap.java:1469)
	at com.wanglei55.mjavalib.myClass$2.run(myClass.java:191)

上面我们在每个线程都获取了迭代器： Iterator<Map.Entry> iterator = entrySet.iterator();我们看下获取迭代器的源码：

public final Iterator<Map.Entry<K,V>> iterator() {
            return new EntryIterator();
        }

直接返回一个新的迭代器，也就是说每个线程有自己的迭代器，初始化的时候各自的expectedModCount等于modCount，当一个线程调用remove()方法后会改变共用的modCount，而另一个线程的expectedModCount依然等于原先的modCount，这样另一个线程在进行迭代操作的时候就会发生并发异常。

那怎么解决呢？有同学估计会想到用Hashtable啊，Hashtable是线程安全的，其实你改造上述代码为Hashtable也同样会发生并发异常，Hashtable线程安全是指的put,get这些方法是线程安全的，而这里的问题是每个线程有自己的迭代器，我们需要给迭代过程加锁，如下：

        final HashMap map = new HashMap();

        for (int i = 0; i < 20; i++) {
            map.put(i,i);
        }

        Thread t1 = new Thread(){
            @Override
            public void run() {
                synchronized (myClass.class){
                    Set entrySet = map.entrySet();
                    Iterator<Map.Entry> iterator = entrySet.iterator();
                    while (iterator.hasNext()){
                        Map.Entry entry = iterator.next();
                        if (entry.getKey().equals(2)){
                            iterator.remove();//改为迭代器删除
                        }
                    }
                }
            }
        };

        Thread t2 = new Thread(){
            @Override
            public void run() {
                synchronized (myClass.class){
                    Set entrySet = map.entrySet();
                    Iterator<Map.Entry> iterator = entrySet.iterator();
                    while (iterator.hasNext()){
                        Map.Entry entry = iterator.next();
                        System.out.println(entry.getKey()+"--->"+entry.getValue());
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        };

        t2.start();
        t1.start();

或者改为支持并发的ConcurrentHashMap，这样就可以解决并发问题了。

最后

以上就是英俊面包为你收集整理的hashCode()方法以及集合中Set的一些总结的全部内容，希望文章能够帮你解决hashCode()方法以及集合中Set的一些总结所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。