1、集合体系框架
    Collection
        |-------List
        特点：
        1、有序（存储和取出元素的顺序是一致的）；
        2、集合中的元素都有索引，所以可以通过索引（角标）来访问元素；
        3、可以存储重复元素。
        |-------Set
        特点：
        1、不包含重复元素；
        2、这个集合存入元素的顺序和取出元素的顺序不一定一致。（具体的容器对象数据结构不同，默认也有不同）
        |------Map：
        特点：
        1、用于存储具备着对应关系的键和值，而且要保证键的唯一性。

2、List集合的基本操作
    1、添加
    add(index,element)
    addAll(index,collection)

    2、删除
    remove(index):获取并删除。

    3、获取
    <1>获取元素：
        Object get(index)
    <2>获取元素索引：
        int indexOf(object);
        int lastIndexOf(object);

    4、修改
        object set(index,element):替换指定位置的元素，并返回被替代的元素；

    5、遍历
        List list = new ArrayList();
        list.add("abc");
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            String str = (String) iterator.next();
            System.out.println(str);
        }

    注意：这里还有一个ListIterator,这个迭代器可以在遍历过程中实现增删改查方法，并且支持逆向遍历。


3、List常见的子类对象
    |-----Vector
    |-----ArrayList
    |-----LinkedList
    <1>Vector可增长的对象数组
    原理：一旦原数组长度不够，会创建新数组，将原数组的元素复制到新数组中，并将新元素
    添加到新数组中。Vector是同步的。

    <2>ArrayList：底层是数组结构，也支持长度可变数组。是不同步的。代替了Vector，
    因为效率高。查询快，增删慢。

    <3>LinkList:底层链表结构，增删效率高，查找效率低
    LinkList的特有方法：addFitst()
         addLast()
         getFirst()
         getLast()
         removeFirst()
         removeLast()

    LinkList应用：可以应用于堆栈和队列；
    堆栈：后进先出。LIFO
    队列：先进先出。FIFO

    题目1：请用LinkedList模拟一个堆栈或者队列数据结构
    题目2：去除数组中相同的元素
    创建一个新的ArrayList，循环遍历原来的数组，将不重复数据添加到新的ArrayList，重            
    复数据取消加入。

    引申出来的问题：ArrayList的contains和remove方法，判断两个元素是否相同，依赖于
    元素中的equals方法。所有当ArrayList存储对象的时候，一定要覆盖equals方法，建立
    根据对象特点的判断相同的依据。

4、Set集合：
    |------HashSet集合
        提供数组的查询效率而出现的。
        将要存储的元素先通过哈希算法算出一个哈希值，来标识存储的位置；要找元素时，先
        将该元素通过哈希算法算出哈希值，在通过哈希值到哈希表中去查。
        特点：
        1、不关心元素顺序。
        2、提高查询效率。
        3、不可能出现重复元素，因为哈希值不同。即使哈希值相同，会再次判断两个元素的      
        equals，内容是否相同。如果内容相同，不存，如果内容不同，存储。
        所以在使用hashSet存储数据的时候，为了保证数据的唯一性，必须要重写hashCode()  
        和equals方法。
    |------TreeSet集合
        特点：
        1、可以给集合中的元素进行指定顺序的排序，默认是通过元素的自然顺序进行排序。
        2、TreeSet集合的主要功能是对元素进行排序的，而TreeSet集合可以通过两种方式。

    实现排序：
    （1）当TreeSet中存储的对象具备比较性的时候，TreeSet排序依赖的是类中的
      compareTo()方法。

    //实现compareTo()的方法
    public class Person implements Comparable{
        private String name;
        private int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public int compareTo(@NonNull Object o) {
            Person person = (Person) o;
            int temp = this.age - person.age;
            return temp==0?this.name.compareTo(person.name):temp;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

    （2）当TreeSet中存储的对象不具备比较性的时候，初始化TreeSet的时候，传入一个
    自定义比较器，来实现排序功能；

    （3）练习：对字符串数组进行长度排序排序，长度相同，进行字典排序。


5、Map集合：
    用于存储具备着对应关系的键和值，而且要保证键的唯一性。
    基本操作：
    （1）添加
    v put(k,v)

    （2）删除
    void clear():清空集合
    v remove(key)：通过键删除元素，并返回对象。

    （3）判断
    boolean containsKey(key)
    boolean containValue(value)
    boolean isEmpty()

    （4）获取
    value get(key) ：获取值；

    示例1：
    public static void mapMethodDemo(Map<Integer,String> map){
        map.put(1,"student1");
        map.put(2,"student2");
        map.put(4,"student4");
        map.put(5,"student5");
        System.out.println(map.put(3,"student3"));
        System.out.println(map.remove(3));
        String name = map.get(5);
    }

    （5）map遍历：
    map是不具备迭代器的，获取原理就是将map集合先转成set集合，然后使用迭代器。
    示例2：
    public static void mapMethodDemo2(Map<Integer,String> map){
        map.put(1,"student1");
        map.put(2,"student2");
        map.put(4,"student4");
        map.put(5,"student5");
        Set<Integer> keySet = map.keySet();
        Iterator<Integer> it = keySet.iterator();
        while(it.hasNext()){
            Integer key = it.next();
            String value = map.get(key);
            System.out.println(key+":::"+value);
        }
    }

    public static void mapMethodDemo3(Map<Integer,String> map){
        map.put(1,"student1");
        map.put(2,"student2");
        map.put(4,"student4");
        map.put(5,"student5");
        Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();
        while(it.hasNext()){
            Map.Entry<Integer,String> me = it.next();
            int key = me.getKey();
            String value = me.getValue();
            System.out.println(key+":::"+value);
        }
    }

    （6）只想获取map中的所有values
    public static void mapMethodDemo4(Map<Integer,String> map){
        map.put(1,"student1");
        map.put(2,"student2");
        map.put(4,"student4");
        map.put(5,"student5");
        Collection<String> values = map.values();
        Iterator<String> it = values.iterator();
        while(it.hasNext()){
            String value = it.next();
            System.out.println(":::"+value);
        }
    }

    （7）Map体系
    |---Hashtable：底层是哈希表数据结构，是线程同步的，不允许null作为键，null作为值
    |---HashMap：底层是哈希表数据结构，是线程不同步的，允许null作为键，null作为值
    |----TreeMap：可以对Map集合中的键进行指定顺序的排序，默认是使用键的自然顺序

    （8）hashMap存储对象
    //hashMap存储对象
    public static void mapSaveObject(Map<StudentDemo,String> map){
        map.put(new StudentDemo("student1",28),"北京");
        map.put(new StudentDemo("student2",28),"北京");
        map.put(new StudentDemo("student3",28),"北京");
        map.put(new StudentDemo("student4",28),"北京");
        map.put(new StudentDemo("student1",28),"北京");

        Set<Map.Entry<StudentDemo,String>> entrySet = map.entrySet();
        Iterator<Map.Entry<StudentDemo,String>> it = entrySet.iterator();
        while(it.hasNext()){
            Map.Entry<StudentDemo,String> me = it.next();
            StudentDemo stu = me.getKey();
            String address = me.getValue();
            System.out.println(stu.getName()+":"+stu.getAge()+":"+address);
        }
    }

    （9）TreeSet存储对象以及排序
    //TreeMap存储对象
    public static void mapSaveObject2(){
        TreeMap<StudentDemo,String> tm = new TreeMap(new Comparator<StudentDemo>()  
    {
            @Override
            public int compare(StudentDemo s1, StudentDemo s2) {
                int temp = s2.getName().compareTo(s1.getName());
                return temp == 0?s1.getAge() - s2.getAge():temp;
            }
        });
        tm.put(new StudentDemo("student1",28),"北京");
        tm.put(new StudentDemo("student2",28),"北京");
        tm.put(new StudentDemo("student3",28),"北京");
        tm.put(new StudentDemo("student4",28),"北京");
        tm.put(new StudentDemo("student1",27),"北京");

        Set<Map.Entry<StudentDemo,String>> entrySet = tm.entrySet();
        Iterator<Map.Entry<StudentDemo,String>> it = entrySet.iterator();
        while(it.hasNext()){
            Map.Entry<StudentDemo,String> me = it.next();
            StudentDemo stu = me.getKey();
            String address = me.getValue();
            System.out.println(stu.getName()+":"+stu.getAge()+":"+address);
        }
    }

    (10)LinkedHashMap基本使用：
    public static void mapMethodDemo5(Map<Integer,String> map){
            HashMap<Integer,String> hm = new LinkedHashMap<>();
            map.put(5,"student5");
            map.put(2,"student2");
            map.put(4,"student4");
            map.put(1,"student1");

            for(Map.Entry<Integer,String> en:hm.entrySet()){
                System.out.println(en.getKey()+":::"+en.getValue());
            }

    //        Set<Integer> keys = hm.keySet();
    //        for(Integer key:keys){
    //            String value = hm.get(key);
    //            System.out.println(key+":::"+value);
    //        }

    //        Collection<String> values = map.values();
    //        Iterator<String> it = values.iterator();
    //        while(it.hasNext()){
    //            String value = it.next();
    //            System.out.println(":::"+value);
    //        }
        }

    （11）练习题目：“abcdvbzvadsza”，获取该字符串中每个字母出现的次数
        要求输出结果：a(2)b(3)c(1)e(3)....

    （12）Map使用小节：
      当分析问题时，发现其中存在映射关系，这时应该想到两个容器，一个是map，一个是
    数组。如果映射关系的一方是有序的编号（可以作为索引），而且映射关系的个数确
    定，建议使用数组。否则，就使用map集合。