高频面试题-Java集合体系

Posted 2021-07-21 墨家巨子@俏如来

Java中的集合体系

Java中的集合分为两大体系，一是继承于Collection接口的List和Set体系，List体系如：ArrayList,LinkedList，Set体系如：TreeSet,HashSet，二是继承于Map接口集合体系如：HashMap,TreeMap等。其中使用到多种数据结构：数组，链表，队列，Hash表等等。

1.Map继承体系

Map是一种key-value的存储结构，最大的有点在于查询效率高，继承体系如下：

Map比较常用的有HashMap和LinkedHashMap,TreeMap。

1.1.LinkedHashMap

LinkedHashMap是在HashMap的基础上保证了元素的插入顺序，它是基于双向链表来实现的。见《HashMap底层原理》，LinkedHashMap 是继承于 HashMap 实现的一种集合，具有 HashMap 的特点外，它还是有序的。

LinkedHashMap源码如下：

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
{
	//一个 LinkedHashMap.Entry 就是HashMap.Node
   static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

	/**
     * The head (eldest) of the doubly linked list.
     */
    transient LinkedHashMap.Entry<K,V> head;

    /**
     * The tail (youngest) of the doubly linked list.
     */
    transient LinkedHashMap.Entry<K,V> tail;
	//true 表示按照访问顺序，会把访问过的元素放在链表后面，放置顺序是访问的顺序
	//false 表示按照插入顺序遍历
	final boolean accessOrder;
	//构造方法
    public LinkedHashMap() {
        super();
        accessOrder = false;
    }

LinkedHashMap中的一个 .Entry 就是HashMap的Node ，只不过LinkedHashMap的Entry中多出来了一个 before, after ，这个是用来保证Entry的插入顺序的。

对于 LinkedHashMap.Entry<K,V> head 和 LinkedHashMap.Entry<K,V> tail 则是用来表示链表的头节点和尾节点的。

具有默认初始容量（16）和加载因子（0.75）。并且设定了 accessOrder = false，表示默认按照插入顺序进行遍历。

LinkedHashMap中没有add方法以及remove方法等，直接调用的是HashMap中的方法，具体见HashMap。

1.2.TreeMap

TreeMap是基于红黑树实现，它默认情况下按照key的compareTo进行自然顺序升续排序，所以put的key需要实现Comparable接口，当然也可以在new TreeMap(Comparator)的时候指定Comparator进行排序。

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable
{
    /**
     * The comparator used to maintain order in this tree map, or
     * null if it uses the natural ordering of its keys.
     *
     * @serial
     * 比较器
     */
    private final Comparator<? super K> comparator;

	//红黑树根节点
    private transient Entry<K,V> root;

    /**
    节点数
     * The number of entries in the tree
     */
    private transient int size = 0;

    /**
     * The number of structural modifications to the tree.
     */
    private transient int modCount = 0;
	//通过构造器指定比较器
    public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }
	//红黑树种的每个节点类型
	static final class Entry<K,V> implements Map.Entry<K,V> {
        K key;				//键
        V value;			//值
        Entry<K,V> left;	//左子树
        Entry<K,V> right;	//有子树
        Entry<K,V> parent;	//父节点
        boolean color = BLACK;	//颜色
        ...省略...
   }

这里可以看到，TreeMap通过 Comparator 进行排序，当然可以通过构造器传入Comparator。添加元素方法如下：

 public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check
			//根节点为空，设置新添加的元素为根节点
            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        //比较器
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
        	//比较器不为空，插入新的元素时，按照comparator实现的类进行排序
            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")
            //如果比较器为空，按照key的自然顺序
                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);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
           //红黑树左旋，右旋操作
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

TreeMap添加元素如果有指定Comparator就按照Comparator排序，否则就使用key进行自然排序。

1.3.HashTable

HashTable与HashMap的区别是HashTable使用同步锁保证了线程安全，HashTable效率比较低使用较少，现在通常使用HashMap，在多线程环境下通常用CurrentHashMap来代替。

2.Collection继承体系：

2.1.List体系

List集合体系中用的比较多的就是ArrayList和LinkedList，他们都拥有元素有序可重复的特点。ArrayList是基于数组实现，随机访问速度比较快，但是低于增删需要进行移位操作，性能比较慢。LinkedList底层基于链表来实现，增删比较快，但是随机访问比较慢，而Vector的方法加了同步锁，可以认为是ArrayList的线程安全版本，但是它是比较古老的一个类，现在用的也比较少。

2.2.Queue队列

Queue是基于队列的一种结构，它可以保证元素先进先出的特点，Deque是双端队列的实现，继承于Queue。LinkedList又是实现与Qeque双端队列，所以如果要使用队列，通常是直接使用LinkedList。PriorityQueue叫做优先队列，它的特点是为每个元素提供一个优先级，优先级高的元素会优先出队列(默认排序是自然排序，队头元素是最小元素,可以通过comparator比较器修改排序的比较方式)。

2.3.Set体系

Set体系包括TreeSet,HashSet，LinkedHashSet等等，Set的特点是不保证元素的插入顺序，而且不允许元素重复，这2点正好和List相反，Set使用hash方法和equals方法来判断元素是否重复，所以存储到Set中的元素需要复写这两个方法。

2.4.TreeSet

TreeSet是基于TreeMap的key实现的存储结构，add的元素就存储到TreeMap的key上，值全是一个Object对象。

另外它默认情况下使用的compareTo进行自然顺序升续排序，所以put的key需要实现Comparable接口，当然也可以在new TreeSet(Comparator)的时候指定Comparator进行排序。

TreeSet的源码：

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable
{
    /**
     * The backing map.
     * 这儿就是TreeSet底层用来存储元素的Map
     */
    private transient NavigableMap<E,Object> m;

    // Dummy value to associate with an Object in the backing Map
    //这个是Map的值，元素存储在map的key上，值全都是 PRESENT 
    private static final Object PRESENT = new Object();

    /**
     * Constructs a set backed by the specified navigable map.
     */
    TreeSet(NavigableMap<E,Object> m) {
        this.m = m;
    }

    /**
    构造一个新的空树集，并根据其元素的自然顺序对其进行排序。
    插入集合中的所有元素都必须实现Comparable接口
     
     * Constructs a new, empty tree set, sorted according to the
     * natural ordering of its elements.  All elements inserted into
     * the set must implement the {@link Comparable} interface.
     * Furthermore, all such elements must be <i>mutually
     * comparable</i>: {@code e1.compareTo(e2)} must not throw a
     * {@code ClassCastException} for any elements {@code e1} and
     * {@code e2} in the set.  If the user attempts to add an element
     * to the set that violates this constraint (for example, the user
     * attempts to add a string element to a set whose elements are
     * integers), the {@code add} call will throw a
     * {@code ClassCastException}.
     */
    public TreeSet() {
    	//new 一个TreeSet 底层就是new了一个TreeMap
        this(new TreeMap<E,Object>());
    }

TreeSet 添加一个元素，就是添加到TreeMap的key上

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

删除一个元素，就是从TreeMap中删除元素

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

其他方法都是调用的map，不多赘述

2.5.HashSet

HashSet是基于HashMap的key实现的存储结构,支持的HashMap实例具有默认的初始容量（16）和负载因子（0.75），add的元素存储到HashMap的key上，值指向一个Object对象。由于底层使用到Hash表，所以HashSet是不会保证元素的插入顺序的。

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;
	//存储元素的HashMap
    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实例具有默认的初始容量（16）和负载因子（0.75）。

     * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
     * default initial capacity (16) and load factor (0.75).
     */
    public HashSet() {
    	//这里创建一个HashMap
        map = new HashMap<>();
    }

存储一个元素，就是存储到HashMap的key上

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

删除一个元素就是从HashMap中删除

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

其他方法都是调用的map，不多赘述

2.6.LinkedHashSet

LinkedHashSet是基于链表和Hash表实现存储结构，它继承于HashSet,它的目的是在HashSet的基础上保证元素插入集合的顺序与输出顺序保持一致，LinkedHashSet 是由 LinkedHashMap 实现的集合,实例具有默认的初始容量(16)负载因子(0.75)。

LinkedHashSet源码

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

	//初始容量 16，负载因子 0.75
	public LinkedHashSet() {
        super(16, .75f, true);
    }
     public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);
    }

上面的构造器调用的是其父类，即HashSet的方法构造方法：

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

添加元素

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

删除元素

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

所以从这里可以看出，LinkedHashSet的功能是由其父类HashSet来实现，而底层存储结构是基于LinkedHashMap的key来实现。

最后来个总结图：

集合	特点	说明
List	1. 有序,可重复2. 可以通过索引访问（下标）	数组(ArrayList)或者链表(LinkedList)存储
Set	1. 无序，不重复	使用Map存储(HashSet - HashMap)
ArrayList	1. 有序2. 随机访问快(下标)3. 插入，删除慢(移位)	底层基于动态数组，内存连续，查询速度快，删除添加要移动数据，性能低下
LinkedList	1. 有序2. 查询慢3. 插入，删除快	双向链表，内存可以不连续，删除，添加快，查询慢
Vector	1. 有序2.线程安全(synchronized)ArrayList的前任	数组 ， 同步锁保证安全性，性能低，不推荐用
PriorityQueue	1. 优先队列2. 默认最小的在前面，按照自然顺序排序	二叉小顶堆(二叉树)
TreeSet	1. 可以保证元素排序(默认自然顺序，可定制)2. 是线程不安全3. 元素不重复(compareTo判断)4. 插入的元素必须实现Comparable接口5. 不允许放入null值	基于TreeMap的KeySet存储数据，使用红黑树实现需要排序时使用TreeSet
HashSet	1. 线程不安全2. 元素不重复(通过hashCode和equals方法判断)3. 元素是无序的4. 只能放入一个null	基于 HashMap 的KeySet储存数据，使用Hash表实现 性能高于TreeSet,优先使用它
LinkedHasHSet extends HashSet	1. 线程不安全2. 元素不重复3. 可以保证元素插入的顺序4. 迭代性能高于HashSet	基于LinkHashMap存储数据，哈希表和双向链表
HashMap	1. 非线程安全 2. 基于哈希表实现3. 通过hashcode实现元素快速查找4. 元素无序5. 可以出现一个null键，多个null值	基于哈希表实现适用于在Map中插入、删除和定位元素
TreeMap	1. 非线程安全2. 基于红黑树实现	基于红黑树实现适用于按自然顺序或自定义顺序遍历键(key)
HashTable	1. 线程安全的2. 性能低下3. 不能有null键和null值	哈希表实现，线程安全，性能低，已经不用了，多线程使用concurrentHashMap

文章到这就结束了把，喜欢的话给个好评哟！！！