java集合面试题整理

HashMap并发环境下会有什么问题

可能会导致死循环和更新丢失问题。

死循环的成因涉及到四个方法，最初的起因是调用put()方法，跟着方法走一遍：
put()方法源码（只给出核心部分）：

public V put(K key, V value)
{
    ......
    //计算Hash值
    int hash = hash(key.hashCode());
    int i = indexFor(hash, table.length);
    //如果该key已存在，则替换掉旧的value
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    //该key不存在，需要增加一个结点
    addEntry(hash, key, value, i);
    return null;
}

当key不存在时，调用addEntry()方法添加新节点。方法源码如下：

void addEntry(int hash, K key, V value, int bucketIndex)
{
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    //查看当前的size是否超过了阈值threshold，如果超过，需要resize
    if (size++ >= threshold)
        resize(2 * table.length);
}

resize()方法就是产生并发死锁的原因

void resize(int newCapacity)
{
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    ......
    //创建一个新的Hash Table
    Entry[] newTable = new Entry[newCapacity];
    //将Old Hash Table上的数据迁移到New Hash Table上
    transfer(newTable);
    table = newTable;
    threshold = (int)(newCapacity * loadFactor);
}

resize()方法的本质就是创建新的Entry数组，将原Map中的元素重新计算位置，加入到新的Map中。虽然死锁的成因是扩充时调用resize()方法，但真正的产生是发生在倒数第三行的transfer()方法中。

void transfer(Entry[] newTable)
{
    Entry[] src = table;
    int newCapacity = newTable.length;
    //从OldTable将元素一个个拿出来，然后放到NewTable中
    for (int j = 0; j < src.length; j++) {
        Entry<K,V> e = src[j];
        if (e != null) {
            src[j] = null;
            do {
                Entry<K,V> next = e.next;
                //计算节点在新的Map中的位置
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            } while (e != null);
        }
    }
}

大体过程如下（摘自网上大神的博客）

假设hash算法就是简单的用key mod Entry数组的长度。这里一定注意e和next的指向，当并发resize()时，这两个指针对于死锁产生起着至关重要的作用。根据方法执行情况，原Map中的链表元素在新的Map中将顺序颠倒，如上图所示，经过一次resize()后key为7的节点排在了key为3的节点之前。

do {
  Entry<K,V> next = e.next;
  //计算节点在新的Map中的位置
  int i = indexFor(e.hash, newCapacity);
  e.next = newTable[i];
  newTable[i] = e;
   e = next;
} while (e != null);

再次黏贴这段代码就是强调这个do while循环就是产生死锁的罪魁祸首。下面模拟死锁产生的过程。
注意，并非所有情况下都会产生死锁，这也需要线程之间的默契配合，怎么讲呢，如图所示：

do {
  Entry<K,V> next = e.next; //假设线程一执行至此被挂起，执行线程二
  int i = indexFor(e.hash, newCapacity);
  e.next = newTable[i];
  newTable[i] = e;
   e = next;
} while (e != null);

此时线程一，e指向key为3的节点，next指向key为7的节点。这点很重要，记下来。去执行线程二。
假设线程二正常执行，结束后的状态如下：

此时线程一被唤醒，线程一的工作空间里，e和next指向的元素依旧是key为3和7的节点。线程一开始执行。

先是执行 newTalbe[i] = e。
然后是e = next，导致了e指向了key(7)。
而下一次循环的next = e.next导致了next指向了key(3)。

目前还没发生问题，线程一接着工作。把key(7)摘下来，放到newTable[i]的第一个，然后把e和next往下移。

e.next = newTable[i] 导致 key(3).next 指向了 key(7)。注意：此时的key(7).next 已经指向了key(3)， 环形链表就这样出现了。

当产生带环链表后，如果调用get()方法，将会陷入死循环，CPU占用将达到100%。

HashMap另外一个并发可能出现的问题是，可能产生元素丢失的现象。

考虑在多线程下put操作时，执行addEntry(hash, key, value, i)，如果有产生哈希碰撞，
导致两个线程得到同样的bucketIndex去存储，就可能会出现覆盖丢失的情况：

那么如何使用线程安全的哈希表结构呢，这里列出了几条建议：

• 使用Hashtable 类，Hashtable 是线程安全的；
• 使用并发包下的java.util.concurrent.ConcurrentHashMap，ConcurrentHashMap实现了更高级的线程安全；
• 或者使用synchronizedMap() 同步方法包装 HashMap object，得到线程安全的Map，并在此Map上进行操作

HashMap和HashTable的区别

• HashMap是非线程安全的(非synchronized)，HashTable是线程安全的(synchronized)。
• HashMap的key和value都可以存储null，HashTable都不可以。
• 由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
• HashMap不能保证随着时间的推移Map中的元素次序是不变的。

HashTable和ConcurrentHashMap的区别

Hashtable和ConcurrentHashMap有什么分别呢？它们都可以用于多线程的环境，但是当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。因为ConcurrentHashMap引入了分割(segmentation)，不论它变得多么大，仅仅需要锁定map的某个部分，而其它的线程不需要等到迭代完成才能访问map。简而言之，在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，而Hashtable则会锁定整个map。

HashMap 的查询时间复杂度

理想情况下是 O(1)的，但是实际中会出现 hash 碰撞，导致无法达到效果。

LinkedList和ArrayList的区别

• LinkedList 底层是基于双向链表实现的，而 ArrayList 底层是基于动态数组实现的；

• 查询的时候 LinkedList 的效率要低于 ArrayList，因为 LinkedList 需要遍历链表，而 ArrayList 底层数组根据下标直接获取数据。

• 插入删除数据的时候，LinkedList 效率比ArrayList 效率高，因为 ArrayList 在数据多的情况下会进行数组扩容或移动数组。

为什么Hashtable ConcurrentHashmap不支持key或者value为null

ConcurrentHashmap和Hashtable都是支持并发的，这样会有一个问题，当你通过get(k)获取对应的value时，如果获取到的是null时，你无法判断，它是put（k,v）的时候value为null，还是这个key从来没有做过映射。HashMap是非并发的，可以通过contains(key)来做这个判断。而支持并发的Map在调用m.contains（key）和m.get(key),m可能已经不同了。