Java面试02|Java集合

关于Java中并发集合有：

（1）CouncurrentHashMap

（2）CopyOnWriteArrayList

（3）LinkedBlockingQueue

（4）ArrayBlockingQueue

这些的适用场景及其实现原理是必须要掌握的。

1、Hash的死锁原因

参考：HashMap 死锁分析 http://github.thinkingbar.com/hashmap-infinite-loop/

2、关于ConcurrentHashMap相关的问题

ConcurrentHashMap的1.7与1.8的实现差别很大，可以参考文章：

（1）谈谈ConcurrentHashMap1.7和1.8的不同实现 http://www.jianshu.com/p/e694f1e868ec

（2）https://zhuanlan.zhihu.com/p/21673805

下面关于ConcurrentHashMap必须要知道的几个问题：

（1）ConcurrentHashMap的锁分段技术。

（2）ConcurrentHashMap的读是否要加锁，为什么。

（3）ConcurrentHashMap的迭代器是强一致性的迭代器还是弱一致性的迭代器。

迭代器在遍历底层数组。在遍历过程中，如果已经遍历的数组上的内容变化了，迭代器不会抛出ConcurrentModificationException异常。如果未遍历的数组上的内容发生了变化，则有可能反映到迭代过程中。这就是ConcurrentHashMap迭代器弱一致的表现

ConcurrentHashMap的结构大概如下所示。

3、LinkedHashMap的应用

LinkedHashMap维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序（insert-order）或者是访问顺序，其中默认的迭代访问顺序就是插入顺序，即可以按插入的顺序遍历元素。基于LinkedHashMap的访问顺序的特点，可构造一个LRU（Least Recently Used）最近最少使用简单缓存。也有一些开源的缓存产品如ehcache的淘汰策略（LRU）就是在LinkedHashMap上扩展的。

public class LruCache<K, V> extends LinkedHashMap<K, V> {
            /** 最大容量 */
            private int maxCapacity;  

            public LruCache(int maxCapacity) {
                super(16, 0.75f, true);
                this.maxCapacity = maxCapacity;
            }  

            public int getMaxCapacity() {
                return this.maxCapacity;
            }  

            public void setMaxCapacity(int maxCapacity) {
                this.maxCapacity = maxCapacity;
            }  

            /**
             * 当列表中的元素个数大于指定的最大容量时，返回true,并将最老的元素删除。
             */
            @Override
            protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
                if (super.size() > maxCapacity) {
                    return true;
                }
                return false;
            }
        }

public class LruCacheTest {  

            public static void main(String[] args) {
                LruCache<String, Object> cache = new LruCache<String, Object>(10);  

                for (int i = 1; i <= 15; i++) {
                    cache.put(i + "", i);
                }  

                // 此时访问指定KEY的元素
                cache.get("10");  

                Iterator<Entry<String, Object>> iterator = cache.entrySet().iterator();
                for (; iterator.hasNext();) {
                    Entry<String, Object> entry = iterator.next();
                    System.out.println("key=" + entry.getKey() + ",value=" + entry.getValue());
                }
            }
        }

输出如下：

key=7,value=7
key=8,value=8
key=9,value=9
key=11,value=11
key=12,value=12
key=13,value=13
key=14,value=14
key=15,value=15
key=10,value=10