综合：集合常见问题总结

Java中的集合

Collection下：List系(有序、元素允许重复)和Set系(无序、元素不重复)

set根据equals和hashcode判断，一个对象要存储在Set中，必须重写equals和hashCode方法

Map下：HashMap线程不同步；TreeMap线程同步

Collection系列和Map系列：Map是对Collection的补充，两个没什么关系

Collection

1. List

• Arraylist： Object数组
• Vector： Object数组
• LinkedList： 双向链表(JDK1.6之前为循环链表，JDK1.7取消了循环)

2. Set

HashSet（无序，唯一）: 基于 HashMap 实现的，底层采用 HashMap 来保存元素

LinkedHashSet： LinkedHashSet 继承于 HashSet，并且其内部是通过 LinkedHashMap 来实现的。

                            有点类似于我们之前说的LinkedHashMap 其内部是基于 HashMap 实现一样，不过还是有一点点区别的

TreeSet（有序，唯一）： 红黑树(自平衡的排序二叉树)

3. Map

HashMap：

JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。

JDK1.8以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间

 

LinkedHashMap：

LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。

另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序

同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。

 

Hashtable：

数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的

 

TreeMap：

红黑树（自平衡的排序二叉树）

 

如何选用集合?

主要根据集合的特点来选用，

比如我们需要根据键值获取到元素值时就选用Map接口下的集合，

需要排序时选择TreeMap,不需要排序时就选择HashMap,

需要保证线程安全就选用ConcurrentHashMap.

当我们只需要存放元素值时，就选择实现Collection接口的集合，

需要保证元素唯一时选择实现Set接口的集合比如TreeSet或HashSet，

不需要就选择实现List接口的比如ArrayList或LinkedList，

然后再根据实现这些接口的集合的特点来选用。

ArrayList和LinkedList区别？

ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

ConcurrentModificationException异常出现的原因

public class Test {
    public static void main(String[] args)  {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(2);
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            Integer integer = iterator.next();
            if(integer==2)
                list.remove(integer);
        }
    }
}

 执行上段代码是有问题的，会抛出ConcurrentModificationException异常。

原因：调用list.remove()方法导致modCount和expectedModCount的值不一致

final void checkForComodification() {
    if (modCount != expectedModCount)
    throw new ConcurrentModificationException();
}

 解决办法：在迭代器中如果要删除元素的话，需要调用Iterator类的remove方法。

public class Test {
    public static void main(String[] args)  {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(2);
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            Integer integer = iterator.next();
            if(integer==2)
                iterator.remove();   //注意这个地方
        }
    }
}

 

HashMap和HashTable、ConcurrentHashMap区别？

相同点:

HashMap和Hashtable都实现了Map接口

都可以存储key-value数据

不同点

HashMap可以把null作为key或value，HashTable不可以

HashMap线程不安全，效率高。HashTable线程安全，效率低。

HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。

什么是fail-fast?
就是最快的时间能把错误抛出而不是让程序执行

 

HashMap 和 Hashtable 的区别

线程是否安全：

HashMap 是非线程安全的，HashTable 是线程安全的；

HashTable 内部的方法基本都经过synchronized 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）；

效率

因为线程安全的问题，HashMap 要比 HashTable 效率高一点。

另外，HashTable 基本被淘汰，不要在代码中使用它；

对Null key 和Null value的支持：

HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。

但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。

初始容量大小和每次扩充容量大小的不同 ：

①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。

HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。

②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，

而 HashMap 会将其扩充为2的幂次方大小（HashMap 中的tableSizeFor()方法保证，下面给出了源代码）。

也就是说 HashMap 总是使用2的幂作为哈希表的大小,后面会介绍到为什么是2的幂次方。

底层数据结构：

JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，

当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。

HashMap 中带有初始容量的构造函数：

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
     public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

 下面这个方法保证了 HashMap 总是使用2的幂作为哈希表的大小。

    /**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }