Java中的集合包括三大类：
        它们是Set、List和Map，它们都处于java.util包中，Set、List和Map都是接口，它们有各自的实现类。
        Set的实现类主要有HashSet和TreeSet。
        List的实现类主要有ArrayList。
        Map的实现类主要有HashMap和TreeMap。


        一、L i s t

        共性：有序  可以重复

        List集合特征：

        （1）允许重复元素添加

        （2）有序：放入的顺序和取出的顺序是一样的

        1、ArrayList 

        （1）没有线程安全，性能高

        （2）容量默认初始容量10，（可以赋初始值） 增长时，容量增加1/2

        容量扩展是按照 + 0.5倍扩展，就是原来集合长度一半

        比如《10+5》《15+7》《22+11》

        2、Vector   

        （1）具有线程安全，性能低  

        （2）容量默认初始容量为10，（可以赋初始值，增长容量） 增长时，容量加倍

        容量扩展是按照 + 1倍扩展，就是原来集合的长度 + 1倍

        比如：<10（原来集合长度）+10（扩展长度）>  <20+20>  <40+40>





        3、LinkedList  链条式集合 （双向链表算法）会有前置节点和后置节点

        找不同点

        ArrayList

        （1）算法：简单的数组算法

        （2）查找：每个元素有固定的索引位置，查找直接根据位置定位获取，性能高

        （3）插入删除：每次操作插入或者删除，都会影响后面元素的索引位置，后面元素都要懂，性能低



        LinkedList

        （1）算法：双向链表式算法

        （2）查找：每次都要从开始往后依次查找，性能低

        （3）插入删除：每次操作插入删除，只需要修改元素的后置节点引用，不需要后面元素移动位置，性能高

        二、Set集合

        1、HashSet

        集合有序无序：放入元素的顺序是否和取出的顺序一致

        TreeSet可以将元素按照规则排序，但是和放入的顺序不同就是无序

        无序（和加入元素的顺序不一样）的，不可以重复的 算法：哈希算法

        Set是接口不能new对象------>实现类HashSet；



        ①、区别：

        取元素的时候不能get

        循环迭代的时候不能使用简单的for循环，

        要用迭代器或者增强型for循环（跟之前一样）



        ②、不可重复

        （1）如何判断对象相同？

        主要是根据对象的hashCode值判断 而equals方法不是主要的

        原则上应该遵循：类重写equals方法  同时重写hashCode方法





        2、TreeSet  语法也是相同的

        SortedSet（Set的子接口）----->TreeSet 实现类

        TreeSet <> = new TreeSet<>();

        集合有序无序：放入元素的顺序是否和取出的顺序一致

        TreeSet可以将元素按照规则排序，但是和放入的顺序不同就是无序

        TreeSet比较对象大小时，

        要使用类的compareTo方法，

        如果（前边>后边）返回正数

        如果（前边<后边）返回负数

        相等返回0，同时认为是相同的对象，不添加重复对象

        引用类型要先转换为Compilable才能进行比较

        TreeSet 判断对象相同时：

        是根据对象的大小判断，如果两个对象大小相等，就认为是相同的对象

        比较大小的compareTo方法 返回0 就是两个相等的对象

        重写compareTo方法时，注意返回0的情况



        Public  cladd  Student  implements  Compilable（接口）{

        }（实现接口Compilable）

        可以自己重写写compareTo方法

        三、集合 Map（接口）


        --------->HashMap（实现类）--->非线程安全

        ---------> Hashtable（实现类）-->线程安全

        Hashtable:语法跟HashMap是一样的

        区别：

        （1）：null

        HashMap 是允许null 作为 key 和 value 的

        Hashtable 不允许 null 作为 key 或

        value 的

        （2）：都实现了 Map 接口

        HashMap 父类是java . util . AbstractMap

        Hashtable 父类是java . util . Dictionary--->di ke shen ne rui --字典的意思

        （3）：线程安全

        HashMap： 非线程安全   性能高

        Hashtable： 线程安全   性能低

        附加使用方法：


        1、创建ArrayList

        ArrayList list = new ArrayList();




        2、添加对象

        List . add(引用数据类型);


        List . add（new integer（1））;-->基本数据类型

        将int --->Integer



        3、集合长度

        List . size（）；



        4、获取某个

        List . get (索引位置);



        5、循环迭代

        1）For 循环：注意长度是size


        2）for each 循环

        for(类型 变量名 ： 集合或者数组){

        变量名 就是每次循环取出的元素

        }

        优点：代码减少简单

        缺点：没有索引位置，用索引位置的话需要自己定义一个计数器


        2）迭代器，循环迭代集合

        Iterator迭代器 接口-->yi te rui ter

        迭代器对象：都是通过要迭代的集合对象 . iterator（） 返回迭代器对象

        Iterator it = list . iterator();

        Hasnext()

        Next();



        While(it . hasNext()){ 判断有没有下一个 有true 没有 false

        Object 0 = it.next(); 向下移动，指向下一个并返回

        System.out.println(o);

        }

        迭代器只能用一次，想在循环必须在长生一个新的迭代器



        6、删除

        （1）List . remove(索引位置 或者 对象);

        这里输入的对象要跟集合里面的对象一模一样才可以被删



        （2）当有多个元素相同需要删除的时候必须使用循环删除（使用迭代器删除）：

        再循环中使用  迭代器删除对象 it . remove(不需要传参数);默认删除当前或最后取出 的元素


        7、判断集合是否为空

        (1)  If（list . size == 0）

        (2)  If ( list . isEmpty )

        (3) 不能写 list == null   



        8、清空集合

        List . clear();

        9、插入

        List . add(int i , Objcet o)

        LinkedList

        除了具有ArrayList的功能还具有

        1、直接在第一个位置添加

        List . addFirst(“    ”);

        2、直接删除第一个位置

        List . removeFirst();不需要传参

        3、直接在最后一个位置添加

        List . addLast(“   ”);

        4、直接删除最后一个

        List . removeLast();不需要传参


        HashMap：



        创建对象

        HashMap map = new HashMap();



        添加元素:

        key-value  键值对 唯一的 key 对应 value

        Map . put( key, value );

        添加时 value 值是可以相同的

        Key 值如果相同 后来的会覆盖原来的 value



        取元素 ：

        通过唯一的key 获取 value

        Map . get( key );



        判断一个键值对是否存在？关键是看 key

        Boolean flag = map . containsKey（key值）;

        If(falg){

        存在（包含）

        }else{

        不存在（不包含）

        }



        删除：

        Map . remove（key）;



        判断集合是否为空：

        Map . isEmpty();



        清空集合：

        Map.clear(); -->ke lai er



        循环迭代：Map不支持迭代器迭代，不支持foreach

        （1）获取所有的key ：keySet() 返回所有的key，是一个set集合

        Set keys = map . keySet();

        For(Object key : keys){

        System.out.print(key+:);（可以不打印）

        System.out.println(map . get(key));

        }



        （2）获取所有的value：values  

        使用map的 values()方法 返回所有的value值的 Collection集合 不能通过value获取key

        Collection coll = map.values():

        for(Object o : coll){

        System.out.println(o);

        }



        （3）Entry---> en chui

        通过map的 entrySet()方法 获取Entry（键值对）的Set集合  

        Entry结构是key-value

        有泛型

        Set <Entry<Integer,Song>> entrys = map.entrySet();

        For(Entry<Integer,Song>  e : entrys){

        Systrm.out.println( e.getkey() + e.getvalue);



        }



        没有泛型（报黄线的那个）

        For(Ovject o : entrys){

        Map . Entry  e  = (Map. Entry) o;

        红色省略

        Entry e = (Entry) o;

        Systrm.out.println( e.getkey() + e.getvalue);

        }


        愿你一生努力
        一生被爱
        最想要的都拥有
        得不到的都释怀
        我的故事很长
        你愿听~
        我愿讲~