Java面试题-集合

集合

1. List和Set的区别

List

​ List继承Collection接口，实现List接口的常见类有：Vector、LinkedList、ArrayList、CopyOnWriteArrayList(JUC包下)。

• Vector：底层数据结构是数组。**线程安全。效率低。**有序，可重复。
• LinkedList：底层数据结构是链表。线程不安全。效率高。有序，可重复。
• ArrayList：底层数据结构是数组。线程不安全。效率高。有序，可重复。

Set

​ Set继承Collection接口，实现Set接口的常见类有：HashSet、LinkedHashSet、TreeSet。

• HashSet：底层数据结构是哈希表。线程不安全。效率高。无序，不可重复。
• LinkedHashSet：底层数据结构是链表和哈希表。线程不安全。效率高。有序，不可重复。
• TreeSet：底层数据结构是红黑树。线程不安全。有序，不可重复。

2. List和Map的区别

List

​ 参考1. List和Set的区别中的List。

Map

​ Map与List和Set最大的区别是不继承于Collection接口，实现Map接口的常见类有：HashMap、LinkedHashMap、TreeMap、HashTable。

• HashMap：JDK7底层数据结构：数组+链表，JDK8底层数据结构：数组+链表+红黑树。线程不安全。效率高。无序，Key不可重复，Value可重复。

  HashMap实现原理及源码分析：HashMap实现原理及源码分析

• LinkedHashMap：底层数据结构与HashMap相同，不同于HashMap：内部提供了Entry替换HashMap中的Node。线程不安全。效率高。有序，Key不可重复，Value可重复。

• TreeMap：底层数据结构为红黑树。线程不安全。效率低于HashMap。有序，根据key排序，Key不可重复，Value可重复。

• HashTable：底层数据结构为数组+链表。线程安全。效率低。无序，Key不可重复，Value可重复。

3. ArrayList和LinkedList的区别

• ArrayList基于数组，LinkedList基于链表。
• ArrayList便于进行查询操作，LinkedList便于进行插入删除操作。
• ArrayList支持高效随机元素访问，LinkedList不支持高效随机元素访问。
• ArrayList空间浪费比LinkedList少。ArrayList空间浪费在于列表结尾预留一定到空间，LinkedList空间浪费在于每个节点前后都需要指向造成的浪费。

4. ArrayList和Vector的区别

• 线程安全&效率：Vector线程安全，底层通过synchronized实现，效率较低；ArrayList非线程安全，效率较高。
• 扩容机制&存储：都采用线性连续存储空间，当存储空间不足，Vector扩容为原来一倍100%；ArrayList扩容为原来一半50%。Vector可以设置扩容的参数，ArrayList不可以

5. HashMap和Hashtable的区别

​ 都是基于哈希表来实现键值映射的工具类。

5.1、继承

HashMap继承于AbstractMap ,Hashtable继承于Dictionary。Dictionary已被废弃⚠️

5.2、空值处理

先说结论：HashMap允许空值，Hashtable空值抛出NullPointerException异常

源码如下：

/*-------HashMap.put()-------*/
public V put(K key, V value) {
  return putVal(hash(key), key, value, false, true);
}

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;
}


/*-------Hashtable.put()-------*/
public synchronized V put(K key, V value) {
  // Make sure the value is not null
  if (value == null) {
    throw new NullPointerException();
  }

  // Makes sure the key is not already in the hashtable.
  Entry<?,?> tab[] = table;
  int hash = key.hashCode();
  int index = (hash & 0x7FFFFFFF) % tab.length;
  @SuppressWarnings("unchecked")
  Entry<K,V> entry = (Entry<K,V>)tab[index];
  for(; entry != null ; entry = entry.next) {
    if ((entry.hash == hash) && entry.key.equals(key)) {
      V old = entry.value;
      entry.value = value;
      return old;
    }
  }

  addEntry(hash, key, value, index);
  return null;
}

5.3、数据结构

都是用哈希表存储键值对。都创建了一个继承自Map.Entry的私有的内部类Entry(Hashtable)或Node(HashMap)，每一个Entry对象表示存储在哈希表中的一个键值对。

5.4、 默认初始值以及扩容机制

Hashtable默认初始值：11，扩容机制为2n+1。

HashMap默认初始值：16，扩容机制为2n。

/*Hashtable*/
//无参构造
public Hashtable() {
  this(11, 0.75f);
}
//扩容方法
protected void rehash() {
  int oldCapacity = table.length;
  Entry<?,?>[] oldMap = table;

  // 扩容为原来的2n+1
  int newCapacity = (oldCapacity << 1) + 1;
  if (newCapacity - MAX_ARRAY_SIZE > 0) {
    if (oldCapacity == MAX_ARRAY_SIZE)
      // Keep running with MAX_ARRAY_SIZE buckets
      return;
    newCapacity = MAX_ARRAY_SIZE;
  }
  Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

  modCount++;
  threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
  table = newMap;

  for (int i = oldCapacity ; i-- > 0 ;) {
    for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
      Entry<K,V> e = old;
      old = old.next;

      int index = (e.hash & 0x7FFFFFFF) % newCapacity;
      e.next = (Entry<K,V>)newMap[index];
      newMap[index] = e;
    }
  }
}

/*HashMap*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//无参构造
public HashMap() {
  this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//扩容方法
//2倍扩容
final Node<K,V>[] resize() {
  Node<K,V>[] oldTab = table;
  int oldCap = (oldTab == null) ? 0 : oldTab.length;
  int oldThr = threshold;
  int newCap, newThr = 0;
  if (oldCap > 0) {
    if (oldCap >= MAXIMUM_CAPACITY) {
      threshold = Integer.MAX_VALUE;
      return oldTab;
    }
    else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
             oldCap >= DEFAULT_INITIAL_CAPACITY)
      newThr = oldThr << 1; // double threshold
  }
  else if (oldThr > 0) // initial capacity was placed in threshold
    newCap = oldThr;
  else {               // zero initial threshold signifies using defaults
    newCap = DEFAULT_INITIAL_CAPACITY;
    newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
  }
  if (newThr == 0) {
    float ft = (float)newCap * loadFactor;
    newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
              (int)ft : Integer.MAX_VALUE);
  }
  threshold = newThr;
  @SuppressWarnings({"rawtypes","unchecked"})
  Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
  table = newTab;
  if (oldTab != null) {
    for (int j = 0; j < oldCap; ++j) {
      Node<K,V> e;
      if ((e = oldTab[j]) != null) {
        oldTab[j] = null;
        if (e.next == null)
          newTab[e.hash & (newCap - 1)] = e;
        else if (e instanceof TreeNode)
          ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
        else { // preserve order
          Node<K,V> loHead = null, loTail = null;
          Node<K,V> hiHead = null, hiTail = null;
          Node<K,V> next;
          do {
            next = e.next;
            if ((e.hash & oldCap) == 0) {
              if (loTail == null)
                loHead = e;
              else
                loTail.next = e;
              loTail = e;
            }
            else {
              if (hiTail == null)
                hiHead = e;
              else
                hiTail.next = e;
              hiTail = e;
            }
          } while ((e = next) != null);
          if (loTail != null) {
            loTail.next = null;
            newTab[j] = loHead;
          }
          if (hiTail != null) {
            hiTail.next = null;
            newTab[j + oldCap] = hiHead;
          }
        }
      }
    }
  }
  return newTab;
}

5.5、 线程安全性

Hashtable是线程安全，底层使用synchronized实现线程安全。

HashMap是非线程安全，效率较Hashtable高。（多线程可使用ConcurrentHashMap）

HashMap和HashTable到底哪不同？ HashMap和HashTable到底哪不同

6. HashSet和HashMap的区别

6.1、 底层数据结构

HashSet不允许存储相同的元素，底层使用HashMap-(Key)存储。HashMap的key元素不允许重复。HashMap底层数据结构（jdk8）：数组、链表、红黑树

6.2、 存储数据

HashSet实现Set接口，存储对象；HashMap实现Map接口，存储键值对。

7. HashMap和ConcurrentHashMap的区别

7.1 所属包

HashMap所属包：java.util.HashMap

ConcurrentHashMap所属包：java.util.concurrent.CurrentHashMap

7.2 线程安全

HashMap非线程安全。

ConcurrentHashMap区分JDK7、JDK8

• ConcurrentHashMap-JDK7

  采用分段锁（Segment）技术，继承ReentrantLock，只有16个Segment。

• ConcurrentHashMap-JDK8

  抛弃分段锁技术，通过CAS+synchronized处理并发。减少内存开销、随着JVM升级提升性能。

8. HashMap的工作原理及代码实现

8.1 不同版本下的差异

• 底层数据结构：JDK7为：数组+链表；JDK8为：数组+链表+红黑树，当链表长度≥8会树化（红黑树）。

  //JDK8
  if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    treeifyBin(tab, hash);
  

• 链表新节点插入顺序：JDK7为头插法，JDK8为尾插法（为了树化）。

  //JDK8
  if ((p = tab[i = (n - 1) & hash]) == null)
    //newNode(hash,key,value,next节点)
    tab[i] = newNode(hash, key, value, null);
  

• hash算法：JDK7hash()较复杂，为了使hash值更加散列而使用复杂运算；JDK8hash()较简洁，由于引入红黑树的概念，无须再用复杂的hash算法消耗算力。

• 扩容机制：JDK7的resize()在多线程扩容的时候可能会出现死循环（JDK7HashMap扩容死循环问题复现）；JDK8的resize()修复了死循环问题。

8.2 默认负载因子（DEFAULT_LOAD_FACTOR）

static final float DEFAULT_LOAD_FACTOR = 0.75f;

负载因子的作用在于计算扩容阈值，当长度≥阈值时进行扩容。保证负载因子✖️容量为整数。

8.3 扩容机制

因为table数组长度必须是2的次方数，扩容其实每次都是按照上一次tableSize位运算得到的就是做一次左移1位运算，假设当前tableSize是16的话 16转为二进制再向左移一位就得到了32 即 16 << 1 == 32 即扩容后的容量，也就是说扩容后的容量是当前容量的两倍。

由于计算机底层不支持乘法运算，都通过指令转化为加法实现，通过位运算能够简洁高效实现✖️2的效果。

8.4 初始容量

默认容量16，且扩容都容量都为2的次方。（4-8太小）

HashMap底层实现原理

HashMap底层实现原理详解

9. ConcurrentHashMap的工作原理及代码实现

具体参考如下两篇文章

ConcurrentHashMap工作原理及实现

ConcurrentHashMap实现原理及源码分析