Java面试--集合

Java集合

1.集合有哪些？

集合分为单列集合Collection和多列集合Map，下面对一些常用的集合简单说明:
① collection包含两个子类list和set：
List：有序，按对象进入方式保存对象，可重复，允许多个null，可以使用迭代器取出元素，也可以使用get获取。具体实现的类有：ArrayList，Vector（是线程安全的ArrayList），LinkedList；
Set：无序，不可重复最多允许一个Null，取元素只能使用迭代器。具体实现的类有：HashSet（基于HashMap实现，无序，快速查找），LinkedHashSet（基于LinkedHashMap实现）。
②Map集合是一种关联数据（可以保存具有映射关系的数据），有两组值key和value。key是唯一值不允许重复，value允许重复。具体实现的类有：HashMap，LinkedHashMap，HashTable(线程安全的)。

2.ArrayList和LinkedList区别？

①ArrayList:使用的是动态数组存储，支持随机查询，查询速度较快。插入删除较慢，非尾插法插入时需要将插入位置后的数据复制一份往后移再插入数据，如果超过容量需要扩容创建新的数组，将数据拷贝新数组里。使用尾插法和固定数组长度可以大大提升性能。
②LinkedList:使用链表结构存储，不适合查询，需要逐一遍历，而插入时只需存储下一个数据地址即可。

3.ArrayList扩容机制？

1.在使用add方法检查是否需要扩容，空数组默认10大小。
2.和当前数组比较，需要最小容量大于当前数组容量需要调用grow方法扩容，扩容原来的1.5倍。
3.扩容后再比较容量是否够，不够就把需要最小的容量设置为新数组容量。
4.任然不够的话就需要调用hugeCapacity()来比较最小容量和数组最大值(integer-8)，超出的话重新设置最大容量(integer最大值)

	源码：
	// 第一步进入添加元素方法
	public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    // 第二部执行ensureCapacityInternal方法
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    // 第三步执行calculateCapacity方法给初始值
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    // 第四步执行ensureExplicitCapacity方法判断需要最小容量minCapacity和当前数组长度elementData.length，大于就需要调用grow方法扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    // 第五步执行grow()方法，扩容为原来的1.5倍，再比较大小还是不够将所需最小熔炉设为数组长度，将新的数组大小和数组最大值比较，大于的话就需要扩容，扩容后进行原数据复制完成扩容。
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    // 第六步执行hugeCapacity()方法
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

4.什么是哈希表？什么是哈希冲突？

哈希表

根据关键码值(Key,Value)而直接进行访问的数据结构。它通过把关键码值key映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表也叫哈希表。

哈希冲突

根据一定的规则放进存放哈希值的数组中，下标为1的数组已经有值了，后面根据规则，判定某个数也需要放到下标为1的数组中，这样就导致了只有一个位置两个人都要坐，就引起了冲突。(不同的key值产生的哈希值是一样的)。

5.怎么解决hash冲突？

解决冲突方法有多种，这里我们只介绍链地址法：

每个哈希表节点都有一个next指针，多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表连接起来。
如下图 下标1的位置有值为1，后面又算出两个同样下标的对象，这就发生了哈希冲突，采用链地址法，可以把 1，2和3放在同一个链表中

6.HashMap？HashTable？

①HashMap和HashTable(弃用)区别：

a.HashTable每个方法都是synchronized修饰，线程安全 。
b.HashMap允许null，HashTable不允许。

②HashMap实现原理：

HashMap底层是数组+链表+红黑树实现。链表在链表长度达到8或者数组长度为64变为红黑树形式。先计算key的hash值二次hash获取数组下标，hash值不同时直接存入数组，相同时就是哈希冲突，进行equals比较相同时直接覆盖，不相同判断链表高度插入。扩容：数组默认为16，负载因子0.75，阈值12超过后进行扩容每次扩容增加一倍。

HashMap的put()方法源码：
 	DEFAULT_INITIAL_CAPACITY = 1 << 4;  // Hash表默认初始容量 16
	MAXIMUM_CAPACITY = 1 << 30;  // 最大Hash表容量，Int的最大值
	DEFAULT_LOAD_FACTOR = 0.75f;  // 负载因子
	TREEIFY_THRESHOLD = 8; // 链表转红黑树阈值
	UNTREEIFY_THRESHOLD = 6; // 树降级称为链表的阈值
	MIN_TREEIFY_CAPACITY = 64; // 树化的另一个参数，当哈希表中的数组元素个数超过64时，会树化
 	transient int size; // 当前哈希表中元素个数
	transient int modCount; // 当前哈希表结构修改次数
	int threshold;  // 扩容阈值，当你的哈希表中的元素超过阈值时，触发扩容(capacity * loadFactor).
	
	// 第一步进入调用put方法执行hash(key)和putVal方法
	public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    // 第二步执行put主要代码
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
         // tab:当前hashMap的散列表；p:散列表中的元素；n:散列表数组长度；i:路由寻址结果
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //初始化逻辑，第一次调用putVal时会初始化散列表
        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 {
        // 不为空时的情况：e：找到了一个与当前要插入的key-value一致的key的元素  k：表示临时的一个key
            Node<K,V> e; K k;
            //表示桶位中的该元素，与你当前插入的元素的key完全一致，然后进行替换
            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 {
            	// 链表的情况，而且链表的头元素与我们要插入的key不一致。
                for (int binCount = 0; ; ++binCount) {
                	// 条件成立的话，说明迭代到最后一个元素了，也没找到一个与你要插入的key一致的node，说明需要加入到当前链表的末尾
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 条件成立的话，说明当前链表的长度，达到树化标准了，需要进行树化
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        	// 树化操作，在里面还判断了需要table的数组长度大于64才会树化
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 条件成立的话，说明找到了相同key的node元素，需要进行替换操作
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // e不等于null，条件成立说明，找到了一个与你插入元素key完全一致的数据，需要进行替换
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //modCount：表示散列表结构被修改的次数，替换Node元素的value不计数
        ++modCount;
        //插入新元素，size自增，如果自增后的值大于扩容阈值，则触发扩容。
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

7.为什么使用红黑树？为什么一开始不使用红黑树？

面试中如果问到，但对红黑树了解不是太多。可以回答红黑树是一个自平衡的二叉查找树，查找效率是非常的高。

主要树的消耗资源比链表更大，红黑树在插入新数据之后，可能会通过左旋、右旋、变色来保持平衡，造成维护成本过高，所以链路较短时，不适合用红黑树。

8.HashMap解决线程不安全问题？

这里讲最常用的一种方案：使用ConcurrentHashMap
1.7使用分段锁思想这里不介绍，感兴趣同学可去了解。
JDK1.8：Synchronized+CAS+(数组+链表+红黑树)结构实现,更加细颗粒度。锁链表的head节点，不影响其它元素读写，读操作无锁也是使用volatile保证被读线程感知。

还是介绍ConcurrentHashMap的put()方法的源码
// 使用volatile修饰散列表，保证其可见性，禁止指令重排。
transient volatile Node<K,V>[] table;
// 第一步调用putVal()方法
public V put(K key, V value) {
        return putVal(key, value, false);
    }
// 首先进入不像HashTable直接用synchronized修饰代码块   
final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        // 进入一个死循环，相当于乐观锁，不符合一直循环操作
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            // 初始化后，还在循环中继续下一轮
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            	// 这里使用cas进行值更新
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            // 表示扩容中
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
            // 最后的循环体。此时出现hash冲突需要链表形式插入值，此时才加入synchronized锁，然后找到冲突的那个节点再循环判断这个节点元素决定插入还是覆盖。
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }