Java 集合常用特点

1:集合：
1） Collection(单列集合)

---------------------------------------------------------------------
        List(有序,可重复)
            ArrayList
                底层数据结构是数组,查询快,增删慢
                线程不安全,效率高
            Vector
                底层数据结构是数组,查询快,增删慢
                线程安全,效率低,几乎不再使用
            LinkedList
                底层数据结构是链表,查询慢,增删快
                线程不安全,效率高

-----------------------------------------------------------------------
        Set(无序,唯一)
            HashSet
                底层数据结构是哈希表。
                哈希表依赖两个方法：hashCode()和equals()

（一般规则:对象equals 是true的话，hashCode需要相同，但是hashCode相同的对象不一定equals，这就是所谓的冲突现象，但是有不同的冲突解决方法。你的hashCode()设计的好的话冲突也就小了。比如楼上给出的超出int范围之后这种hashCode()实现，对象肯定是无数的，但是hash实现是有限的呢,所以冲突了。）
                执行顺序：
                    首先判断hashCode()值是否相同
                        是：继续执行equals(),看其返回值
                            是true:说明元素重复，不添加
                            是false:就直接添加到集合
                        否：就直接添加到集合
                最终：
                    自动生成hashCode()和equals()即可
                    
            LinkedHashSet
                    底层数据结构由链表和哈希表组成。
                    由链表保证元素有序。
                    由哈希表保证元素唯一。

TreeSet
                底层数据结构是红黑树。(是一种自平衡的二叉树)，存储的元素必须是同一类型

如何保证元素唯一性呢?
                    根据比较的返回值是否是0来决定
                如何保证元素的排序呢?
                    两种方式
                        自然排序(元素具备比较性)
                            让元素所属的类实现Comparable接口

Set set = new TreeSet();
        // 当Person类没有实现Comparable接口时，当向TreeSet中添加Person对象时，报ClassCastException
        set.add(new Person("CC", 23));
        set.add(new Person("MM", 21));
        set.add(new Person("GG", 25));
        set.add(new Person("JJ", 24));
        set.add(new Person("KK", 20));
        set.add(new Person("DD", 20));
        // set.add("AA");

        for (Object str : set) {
            System.out.println(str);
        }

比较器排序(集合具备比较性)
                            让集合接收一个Comparator的实现类对象

// 1.创建一个实现了Comparator接口的类对象
        Comparator com = new Comparator() {
            // 向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer
            // 的哪个属性排序的。
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Customer && o2 instanceof Customer) {
                    Customer c1 = (Customer) o1;
                    Customer c2 = (Customer) o2;
                    int i = c1.getId().compareTo(c2.getId());
                    if (i == 0) {
                        return c1.getName().compareTo(c2.getName());
                    }
                    return i;
                }
                return 0;
            }
        };
        // 2.将此对象作为形参传递给TreeSet的构造器中
        TreeSet set = new TreeSet(com);
        // 3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象。
        set.add(new Customer("AA", 1003));
        set.add(new Customer("BB", 1002));
        set.add(new Customer("GG", 1004));
        set.add(new Customer("CC", 1001));
        set.add(new Customer("DD", 1001));

        for (Object str : set) {
            System.out.println(str);
        }

---------------------------------------------------------------------
 2）Map(双列集合)
        A:Map集合的数据结构仅仅针对键有效，与值无关。
        B:存储的是键值对形式的元素，键唯一，值可重复。
        
        HashMap
            底层数据结构是哈希表。线程不安全，效率高
                哈希表依赖两个方法：hashCode()和equals()
                执行顺序：
                    首先判断hashCode()值是否相同
                        是：继续执行equals(),看其返回值
                            是true:说明元素重复，不添加
                            是false:就直接添加到集合
                        否：就直接添加到集合
                最终：
                    自动生成hashCode()和equals()即可

---------------------------------------------------------------------
        LinkedHashMap
                底层数据结构由链表和哈希表组成。
                    由链表保证元素有序。
                    由哈希表保证元素唯一。

---------------------------------------------------------------------
        Hashtable
            底层数据结构是哈希表。线程安全，效率低
                哈希表依赖两个方法：hashCode()和equals()
                执行顺序：
                    首先判断hashCode()值是否相同
                        是：继续执行equals(),看其返回值
                            是true:说明元素重复，不添加
                            是false:就直接添加到集合
                        否：就直接添加到集合
                最终：
                    自动生成hashCode()和equals()即可

---------------------------------------------------------------------
        TreeMap
            底层数据结构是红黑树。(是一种自平衡的二叉树)
                如何保证元素唯一性呢?
                    根据比较的返回值是否是0来决定
                如何保证元素的排序呢?
                    两种方式（同上TreeSet）
                        自然排序(元素具备比较性)
                            让元素所属的类实现Comparable接口
                        比较器排序(集合具备比较性)
                            让集合接收一个Comparator的实现类对象

---------------------------------------------------------------------
    
2:到底使用那种集合：
    看需求。
    
    是否是键值对象形式:
        是：Map
            键是否需要排序:
                是：TreeMap
                否：HashMap
            不知道，就使用HashMap。
            
        否：Collection
            元素是否唯一:
                是：Set
                    元素是否需要排序:
                        是：TreeSet
                        否：HashSet
                    不知道，就使用HashSet
                    
                否：List
                    要安全吗:
                        是：Vector(其实我们也不用它,后面我们讲解了多线程以后，我在给你回顾用谁)
                        否：ArrayList或者LinkedList
                            增删多：LinkedList
                            查询多：ArrayList
                        不知道，就使用ArrayList
            不知道，就使用ArrayList
            
3:集合的常见方法及遍历方式
    Collection:
        add()
        remove()
        contains()
        iterator()
        size()
        
        遍历方式：
            增强for
            迭代器
            
        |--List
            get()
            
            遍历：
                普通for
        |--Set
    
    Map:
        put()
        remove()
        containskey(),containsValue()
        keySet()
        get()
        value()
        entrySet()
        size()
        
        遍历方式：
            根据键找值

根据键值对对象分别找键和值。