【面试专栏】第六篇：Java基础:集合篇-HashSet、TreeSet

🎉Set

• 没有顺序，不可重复

HashSet（底层是HashMap)

• Set不允许元素重复、无序
• 基于HashMap实现，无容量限制
• 是非线程安全的
• 扩容机制与HashMap一致
• Fail-fast 模式迭代器

成员变量

可以看到是基于HashMap 实现，PRESENT 去填充map 的 value 节省空间，利用了map key的唯一性

private transient HashMap<E,Object> map;

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

构造方法

构造方法中创建的是一个hashmap

/**
 * 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<>();
}

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

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

添加

根据map中的特性来判断是否存在，添加成功

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

删除

相同使用map的remove方法

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

遍历

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

包含

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

🎉TreeSet（底层是TreeMap)

• 基于TreeMap实现，支持排序（自然排序 或者 根据创建TreeSet 时提供的 Comparator 进行排序)
• 是非线程安全的
• Fail-fast 模式迭代器
• 实现了NavigableSet 接口，支持排序与其他一些扩展
  • 直接获取符合条件的最近的元素，这里条件主要是 lower(>)、 floor(>=)、 higher(<)、 ceiling(<=)。如果符合条件的元素不存在，就返回 null。
  • 逆向访问：descendingSet，descendingIterator
  • 获取并弹出最大/最小值：pollFirst，pollLast
  • 增强了 subSet 和 tailSet
  • SortedSet 返回的集合边界是左闭右开的（也就是说，[a, b)），NavigableSet 提供了另一个版本，制定左右边界是否闭合。

成员变量

其中包含了一个NavigableMap，具体传入构造的是TreeMap（TreeMap 继承了 NavigableMap）

/**
 * The backing map.
 */
private transient NavigableMap<E,Object> m;

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

构造方法

直接传入的就是TreeMap

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

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

添加

然后下面就是map的常规调用操作

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

删除

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

遍历

public Iterator<E> iterator() {
    return m.navigableKeySet().iterator();
}

包含

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

基于SortedMap ，获取开头

基于SortedMap 做的实现，有顺序才有开头和结尾

public E first() {
    return m.firstKey();
}

获取结尾

public E last() {
    return m.lastKey();
}

NavigableMap 实现的功能

• 子集
  同样有顺序才能从一个到另一个中间生成子集

public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                              E toElement,   boolean toInclusive) {
    return new TreeSet<>(m.subMap(fromElement, fromInclusive,
                                   toElement,   toInclusive));
}

• 默认是含头不含尾

public SortedSet<E> subSet(E fromElement, E toElement) {
    return subSet(fromElement, true, toElement, false);
}

SortedSet功能

public interface SortedSet<E> extends Set<E> {
    /**
     * 返回比较器，如果是自然排序返回 null 
     */
    Comparator<? super E> comparator();

    /**
     * 返回 e1 和 e2 之间的元素，包括 e1,不包括 e2
     */
    SortedSet<E> subSet(E fromElement, E toElement);

    /**
     * 返回 e 之前的元素，不包括 e
     */
    SortedSet<E> headSet(E toElement);

    /**
     * 返回 e 之后的元素，不包括 e
     */
    SortedSet<E> tailSet(E fromElement);

    /**
     * 返回第一个元素
     */
    E first();

    /**
     * 返回最后一个元素
     */
    E last();

    @Override
    default Spliterator<E> spliterator() {
        return new Spliterators.IteratorSpliterator<E>(
                this, Spliterator.DISTINCT | Spliterator.SORTED | Spliterator.ORDERED) {
            @Override
            public Comparator<? super E> getComparator() {
                return SortedSet.this.comparator();
            }
        };
    }
}

NavigableSet的功能

public interface NavigableSet<E> extends SortedSet<E> {
    /**
     * 严格返回小于元素e的最大元素，没有则返回null
     */
    E lower(E e); 
 
    /**
     *返回小于或者等于元素e的最大元素，没有则返回null
     */
    E floor(E e);
 
    /**
     * 返回大于或者等于元素e的最小元素，没有则返回null
     */
    E ceiling(E e);
 
    /**
     * 严格返回大于元素e的最小元素，没有则返回null
     */
    E higher(E e);
 
    /**
     * 返回并移除集合中第一个元素，没有则返回null
     */
    E pollFirst();
 
    /**
     * 返回并移除集合中最后一个元素，没有则返回null
     */
    E pollLast();
 
    /**
     * 按升序返回此集合中元素的迭代器
     */
    Iterator<E> iterator();
 
    /**
     * 返回包含该集合中元素的逆序视图
     */
    NavigableSet<E> descendingSet();
 
    /**
     * 按降序返回此集合中元素的迭代器。
     */
    Iterator<E> descendingIterator();
 
    /**
     * 返回集合中在fromElement到toElement的元素构成的新集合，fromInclusive和toInclusive表示是否包含头和尾
     */
    NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                           E toElement,   boolean toInclusive);
 
    /**
     * 返回小于toElement的元素构成的新集合，inclusive表示是否包含元素toElement
     */
    NavigableSet<E> headSet(E toElement, boolean inclusive);
 
    /**
     * 返回大于toElement的元素构成的新集合，inclusive表示是否包含元素fromElement
     */
    NavigableSet<E> tailSet(E fromElement, boolean inclusive);
 
    /**
     * <p>Equivalent to {@code subSet(fromElement, true, toElement, false)}.
     * 返回集合中在fromElement到toElement的元素构成的新集合，fromInclusive和toInclusive表示包含头不包含尾
     */
    SortedSet<E> subSet(E fromElement, E toElement);
 
    /**
     * <p>Equivalent to {@code headSet(toElement, false)}.
     * 返回小于toElement的元素构成的新集合，不包含元素toElement
     */
    SortedSet<E> headSet(E toElement);
 
    /**
     * <p>Equivalent to {@code tailSet(fromElement, true)}.
     * 返回大于toElement的元素构成的新集合，不包含元素toElement
     */
    SortedSet<E> tailSet(E fromElement);

}