本文基于Java1.8
set 和list 一样都是Collection 的子类
set 存放的数据不可以重复
三个实现类
hashSet linkedHashSet treeSet AbstractSet
hashSet 特点:元素不允许重复,可以为null,无序的,线程不安全
(1)hashSet 是基于hashMap实现的,默认的构建函数是初始化一个hashMap,如下:
其实就是相当于把 存入HashSet的值,当成了HashMap的key值来存储,value 存的是present对象。
(2)HashSet实现set接口,由哈希表(实际上是一个HashMap实例)支持。它不保证set 的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用null元素。
LinkedHashSet 继承HashSet 同时有基于linkedHashMap的实现原理
特点:保留插入顺序
底层使用LinkedHashMap 来保存元素,加了链表的数据结构功能。
所以特点是在hashSet 的基础上,无序变成了有序的,
代码就几个构造方法,但是是直接向上,调用父类的构造方法,父类hashSet 专门给他的构造方法如下,新建了一个LinkedHashMap,初始大小是16,负载因子0.75;
treeSet 特点:排序
treeSet 的实现原理是利用treeMap
支持自然排序和定制排序 默认自然排序
treeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系,然后将集合元素按升序排列,这种方式就是自然排序。(比较的前提:两个对象的类型相同)
TreeSet的自然排序是根据集合元素的大小,TreeSet将他们以升序排列。如果需要实现定制排序,例如降序,则可以使用Comparator接口。该接口里包含一个int compare(T o1, T o2)方法,该方法用于比较o1和o2的大小。 如果需要实现定制排序,则需要在创建TreeSet集合对象时,并提供一个Comparator对象与该TreeSet集合关联,由该Comparator对象负责集合元素的排序逻辑。
AbstractSet 是以上子类的父类,重写了equals和hashCode方法以及removeAll方法。源码如下
public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> { /** * Sole constructor. (For invocation by subclass constructors, typically * implicit.) */ protected AbstractSet() { } // Comparison and hashing /** * Compares the specified object with this set for equality. Returns * <tt>true</tt> if the given object is also a set, the two sets have * the same size, and every member of the given set is contained in * this set. This ensures that the <tt>equals</tt> method works * properly across different implementations of the <tt>Set</tt> * interface.<p> * * This implementation first checks if the specified object is this * set; if so it returns <tt>true</tt>. Then, it checks if the * specified object is a set whose size is identical to the size of * this set; if not, it returns false. If so, it returns * <tt>containsAll((Collection) o)</tt>. * * @param o object to be compared for equality with this set * @return <tt>true</tt> if the specified object is equal to this set */ public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Collection<?> c = (Collection<?>) o; if (c.size() != size()) return false; try { return containsAll(c); } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } } /** * Returns the hash code value for this set. The hash code of a set is * defined to be the sum of the hash codes of the elements in the set, * where the hash code of a <tt>null</tt> element is defined to be zero. * This ensures that <tt>s1.equals(s2)</tt> implies that * <tt>s1.hashCode()==s2.hashCode()</tt> for any two sets <tt>s1</tt> * and <tt>s2</tt>, as required by the general contract of * {@link Object#hashCode}. * * <p>This implementation iterates over the set, calling the * <tt>hashCode</tt> method on each element in the set, and adding up * the results. * * @return the hash code value for this set * @see Object#equals(Object) * @see Set#equals(Object) */ public int hashCode() { int h = 0; Iterator<E> i = iterator(); while (i.hasNext()) { E obj = i.next(); if (obj != null) h += obj.hashCode(); } return h; } /** * Removes from this set all of its elements that are contained in the * specified collection (optional operation). If the specified * collection is also a set, this operation effectively modifies this * set so that its value is the <i>asymmetric set difference</i> of * the two sets. * * <p>This implementation determines which is the smaller of this set * and the specified collection, by invoking the <tt>size</tt> * method on each. If this set has fewer elements, then the * implementation iterates over this set, checking each element * returned by the iterator in turn to see if it is contained in * the specified collection. If it is so contained, it is removed * from this set with the iterator's <tt>remove</tt> method. If * the specified collection has fewer elements, then the * implementation iterates over the specified collection, removing * from this set each element returned by the iterator, using this * set's <tt>remove</tt> method. * * <p>Note that this implementation will throw an * <tt>UnsupportedOperationException</tt> if the iterator returned by the * <tt>iterator</tt> method does not implement the <tt>remove</tt> method. * * @param c collection containing elements to be removed from this set * @return <tt>true</tt> if this set changed as a result of the call * @throws UnsupportedOperationException if the <tt>removeAll</tt> operation * is not supported by this set * @throws ClassCastException if the class of an element of this set * is incompatible with the specified collection * (<a href="Collection.html#optional-restrictions">optional</a>) * @throws NullPointerException if this set contains a null element and the * specified collection does not permit null elements * (<a href="Collection.html#optional-restrictions">optional</a>), * or if the specified collection is null * @see #remove(Object) * @see #contains(Object) */ public boolean removeAll(Collection<?> c) { Objects.requireNonNull(c); boolean modified = false; if (size() > c.size()) { for (Iterator<?> i = c.iterator(); i.hasNext(); ) modified |= remove(i.next()); } else { for (Iterator<?> i = iterator(); i.hasNext(); ) { if (c.contains(i.next())) { i.remove(); modified = true; } } } return modified; } }