集合分类以及各自的特点

集合分为Map和Collection两大类


1.ArrayList 是有序的，可重复，底层数据结构是数组，查询快，增删慢，线程不安全，效率高

2.Vector 是有序的，可重复，底层数据结构是数组，查询快，增删慢，线程安全，效率低

3.LinkedList 是有序的，可重复，底层数据结构是链表，查询慢，增删快，线程不安全，效率低

4.Hashset 无序 唯一 底层数据结构是链表和哈希表，通过hashcode()和equals()来确定唯一性，当hashcode()的值相同时，才会去调用equals()方法来确定唯一性性，当想自己定义唯一性时可以在对象类中重写hashcode()和equals()方法。

5.TreeSet底层数据结构是红叉树(红黑树是一种自平衡的二叉树)，存储容器是TreeMap,我们可以从源码上看出来

 public class TreeSet<E> extends AbstractSet<E> 
    implements NavigableSet<E>, Cloneable, java.io.Serializable 
 { 
    // 使用 NavigableMap 的 key 来保存 Set 集合的元素
    private transient NavigableMap<E,Object> m; 
    // 使用一个 PRESENT 作为 Map 集合的所有 value。
    private static final Object PRESENT = new Object(); 
    // 包访问权限的构造器，以指定的 NavigableMap 对象创建 Set 集合
    TreeSet(NavigableMap<E,Object> m) 
    { 
        this.m = m; 
    } 
    public TreeSet()                                      // ①
    { 
        // 以自然排序方式创建一个新的 TreeMap，
        // 根据该 TreeSet 创建一个 TreeSet，
        // 使用该 TreeMap 的 key 来保存 Set 集合的元素
        this(new TreeMap<E,Object>()); 
    } 
    public TreeSet(Comparator<? super E> comparator)     // ②
    { 
        // 以定制排序方式创建一个新的 TreeMap，
        // 根据该 TreeSet 创建一个 TreeSet，
        // 使用该 TreeMap 的 key 来保存 Set 集合的元素
        this(new TreeMap<E,Object>(comparator)); 
    } 
    public TreeSet(Collection<? extends E> c) 
    { 
        // 调用①号构造器创建一个 TreeSet，底层以 TreeMap 保存集合元素
        this(); 
        // 向 TreeSet 中添加 Collection 集合 c 里的所有元素
        addAll(c); 
    } 
    public TreeSet(SortedSet<E> s) 
    { 
        // 调用②号构造器创建一个 TreeSet，底层以 TreeMap 保存集合元素
        this(s.comparator()); 
        // 向 TreeSet 中添加 SortedSet 集合 s 里的所有元素
        addAll(s); 
    } 
    //TreeSet 的其他方法都只是直接调用 TreeMap 的方法来提供实现
    ... 
    public boolean addAll(Collection<? extends E> c) 
    { 
        if (m.size() == 0 && c.size() > 0 && 
            c instanceof SortedSet && 
            m instanceof TreeMap) 
        { 
            // 把 c 集合强制转换为 SortedSet 集合
            SortedSet<? extends E> set = (SortedSet<? extends E>) c; 
            // 把 m 集合强制转换为 TreeMap 集合
            TreeMap<E,Object> map = (TreeMap<E, Object>) m; 
            Comparator<? super E> cc = (Comparator<? super E>) set.comparator(); 
            Comparator<? super E> mc = map.comparator(); 
            // 如果 cc 和 mc 两个 Comparator 相等
            if (cc == mc || (cc != null && cc.equals(mc))) 
            { 
                // 把 Collection 中所有元素添加成 TreeMap 集合的 key 
                map.addAllForTreeSet(set, PRESENT); 
                return true; 
            } 
        } 
        // 直接调用父类的 addAll() 方法来实现
        return super.addAll(c); 
    } 
    ... 
 } 

从上面代码可以看出，TreeSet 的 构造器的都是新建一个 TreeMap 作为实际存储 Set 元素的容器，TreeSet 底层实际使用的存储容器就是 TreeMap。他插入数据的时候是无序的，但是输出的结果排序是有序的且同样具有唯一性。排序有自然排序和比较器排序，TreeSet 真正的比较是依赖于元素的 compareTo()方法，而这个方法是定义在 Comparable 接口里面的。所以，你要想重写该方法，就必须先实现 Comparable 接口。这个接口表示的就是自然排序。
5.LinkedHashSet 底层数据结构是链表和哈希表，链表保证元素有序，哈希表保证元素唯一
6.TreeMap是排序有序的，HashMap和HashTable是无序的，HashTable是线程安全的，效率低，不允许null值，HashMap是线程不安全的，效率高，允许null值(key和value都允许)