集合和数组的区别：
        集合;长度可变，只能存储引用数据类型
        数组：长度固定，既可以存储基本数据类型，也可以存储引用数据类型

集合的体系结构：集合类有很多，不断地抽取共性，则形成了体系结构
        只要是Collection的实现类，则一定拥有Collection的方法
        Collection
            --List:有序（存和取的顺序），有索引，允许重复
                常用方法：
                        c.add("ad");//添加指定元素，返回是否添加成功
                        c.clear();//删除集合中的所有元素
                        c.contains("ad");//判断集合中是否包含指定元素
                        c.isEmpty();//判断集合是否为空（元素的个数是否为0）
                        c.remove("ad");//删除指定元素第一个出现的那个，返回是否删除功能（当元素不存在则删除失败）
                        c.size();//返回元素个数
                        c.toArray();//将集合转为数组
                --ArrayList
                --LinkedList
                --Vector
            --Set：无序（不保证存和取的顺序一致），无索引，不允许重复
                --HashSet
                    --LinkedHashSet
                --TreeSet
        Iterator:迭代器借口：
                boolean hasNext() 判断是否还有元素可以进行迭代
                E next（） 取出指定元素
                工作原理：
                        1.默认迭代器对象会指向集合的第一个元素，
                        2.可以先通过hasNext判断是否有指向位置的元素，如果有元素，则返回true
                        3.如果有元素，则可以通过next方法取出指定位置的元素
                注意事项：使用迭代器时，不能在使用过程中进行集合元素的添加或者删除

                解决并发修改异常：（略）
                        1.不要使用迭代器来遍历集合，使用转数组的方式
                        2.在需要修改集合的时候，不使用集合，用迭代器操作
                        ListIterator<String> it = c.listIterator//只有list中才能使用

增强for循环（foreach）:
        格式：
            for（元素类型 变量名 ：数组/集合） {}
        工作原理：
                每次都会将集合的元素赋值个冒号左边的变量，我们就可以通过操作变量从而操作集合中的元素
泛型
        使用泛型的好处：
                1.限定了集合中存储的数据类型，减少因为类型转换带来的一些问题
                2.简化代码的书写，可以不用向下转型
        定义泛型类：
                在定义类的时候在类名后声明泛型，当我们创建
                class Box<E>{}
        定义泛型接口：
                1.在定义实现类的时候，直接确定借口中的泛型具体类型
                        interface Box<E>{        }
                        class BoxImpl implements Box<String> {        }
                2.在定义实现类的时候不确定泛型的类型，但是在创建实现类对象的时候再去确定其具体类型
                        interface Box<E> {        }
                        class BoxImpl<E> implemrnts Box<E> {        }
                        BoxImpl<String> b = new BoxImpl<String>()
                泛型的边界：
                        1.？是一个通配符，如果泛型定义的类型是？代表可以传递任意类型的数据
                                public static void method(ArrayList<?> list) {        }
                        2.? extents Person 代表可以传递Person类型，以及其子类型
                                public static void method(ArrayList<? extents Person> list) {        }
                        3.? super Person 代表可以传递Person类型，以及其父类型
                                public static void method(ArrayList<? super Person> list) {        }

数据结构：
        栈：先进后出
           特点：
                1.只能在一端进行元素的添加和删除
                2.先进后出（*
                        入口和出口在同一侧，先进去的元素后出来
        队列：
           特点：
                1.先进先出（*）       
                2.入口和出口分别在两端
        数组：
           特点：
                1.增删慢：长度不可变
                2.查询快：元素有对应的索引，是一片连续的内存空间
        链表结构:
                每个元素都是一个对象，对象中包含的元素数据，指针每个元素之间，通过指针相连
           单向链表特点：
                1.增删快：增删元素不会改变原有内容
                2.查询慢：查询只能依次查询
           双向链表：
                相比单向链表：查询稍微快一点
        红黑树：
           特点：
                查询速度快
           名词解释：
                二叉树：分支不超过两个
                查找树/排序树：是一个有序的二叉树（左子树小于节点，右子树大于节点）左中右，则是从小到大的顺序
                平衡树：左右子树高度差不超过1
                红黑树：趋近于平衡树，查询速度非常快
        java.uitl.List
                概述：
                    是Collection下的一个子接口，在list接口下的集合都有以下特点
                        1.有序
                        2.右索引
                        3.允许重复
                List中的特有功能（和索引相关的增删改查的功能）
                        add(int index,E element):在指定索引位置添加元素
                        remove(int index):删除指定位置的元素，吧被删除的元素返回
                        set(int index, E element):修改指定索引位置的元素为指定值，把被修改的元素返回
                        get(int index):获取指定索引位置的元素

                Arraylist:底层实现的数组
                LinkedList：
                        1.底层是一个链表结构：查询慢，增删快
                        2.里边包含了大量操作首尾元素的方法
                        注意：使用LinkedList集合特有的方法，不能使用多态
                        addFirst(E e):将制定元素插入此列表的开头
                        addLast(E e):将制定元素添加到此列表的结尾
                        push(E e):将元素推入此列表所表示的堆栈

                        getFirst():返回此列表的第一元素
                        getLast():返回此列表的最后一个元素

                        removeFirst():移除并返回此列表的第一元素
                        removeLast():移除并返回此列表的最后一个元素
                        pop():从此列表所表示的堆栈处弹出一个元素
                        isEmpty():如果列表不包含元素，则返回true
                                可以模拟栈和队列
                Vector：
                        和ArrayList实现功能是一致的（底层也是数组的实现）
                        唯一的区别：
                                ArrayList不同步的（效率高，安全性低）
                                Vector

        Set接口的特点：
                1.不允许存储重复的元素
                2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
               
        HashSet的特点：
                底层是hash表的实现，查询的效率非常高
                1.不允许存储重复的元素
                2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
                3.是一个无序的集合，存储元素和取出元素的顺序有可能不一致
                4.可以使用迭代器和增强for循环遍历
        哈希值：
                默认情况：根据对象的物理地址算出索引位置
        HashSet的存储原理：
                通过hashCode方法确定索引位置
                再通过equals方法去除重复元素
                总结：
                     存储元素的操作：
                        1.先获取对象的hash值去存储元素
                                hash值不一样，直接存储
                                hash值一样
                                   则比较equals的返回值
                                        如果是true则认为元素重复
                                        如果false，则认为元素不重复，则添加元素
                当我们用HashSet存储自定义对象的时候，如果想保证元素的唯一性，则需要重写hashCode和equals方法
                        alt + insert
        LinkedHashSet:本质就是一个有序的HashSet：hash表+链表
                        hash表用于存储元素
                        链表用于记录元素存储的顺序，当我们获取元素的时候，则会通过链表记录的顺序去获取元素
        可变参数：
           一种特殊的参数类型，可以接受任意多个同种数据类型的数据：0个，1个···此类型的数组

                格式：
                        数据类型...参数名
                原理：
                        将传毒的任意多个元素，封装到一个数组中，最后再传递给可变参数的变量
        1.Comparator 比较器对象，一个额外的比较规则
       
        格式
        Collections.sort(arr, new Comparator<JiHeLei>() {
            @Override
            public int compare(JiHeLei o1, JiHeLei o2) {
                return o1.getAge()- o2.getAge();
            }
        });
        2.Comparable 让对象所在的类去实现，实现后，则可以使用sort方法实现对元素的排序
                在调用Collections.sort方法的时候，除了传递被排序的集合，还传递一个比较器实现类对象


去重复的原理：
        1.首先通过元素hashCode方法获取哈希值，计算出元素在哈希表中的位置
        2.如果对应位置已经有元素了，通过equals比较元素的内容
               
        HashSet存储自定义对象，元素所在的类必须重写hashCode和equals方法


java.utli.Map(k,v)

Map集合
        特点：
                1. 每个元素有键值对组成
                2. key不可重复，value可以重复
                   3. 可以通过key找到对应的值value
        Map的实现类介绍

                HashMap：底层是哈希表的实现（HashMap中的键其实就是HashSet）
                   LinkedHashMap  就是一个有序的HashMap
                   put方法添加元素，如果键不存在，直接添加，put方法返回null


                Hashtable
                        Properties

        比较：
           Hashtable是同步的，Hashtable不允许null键和null值
           HashMap是不同步的，HashMap允许null键和null值，但是null键只能出现一次

        Map的常用方法/功能：
                V put（K k，V v）添加元素，如果键已经存在则用新值替换旧值，并返回旧值
                V remove（K k）按照给定的删除整个键值对，并且返回被删除的值
                V get（Object key）获取指定键对应的值（通过建获取值）
                boolean containsKey（Object key）判断指定的键是否存在
                boolean containsValue（Object value）判断指定的值是否存在

        Map的常用遍历方法/功能：
                Set<K> keySet() 获取包含所有键的Set集合  其实HashMap中的键就相当于一个HashSet (键找值的方式遍历Map集合)
                        Set<String> keys = map.keySet();
                Set<Map.Entry<K,V>> entrySet() 获取所有包含键值对元素（Entry）的Set集合
                        Set<Map.Entry<String,String>> set = map.entrySet();
        用HashMap存储自定义对象
                由于HashMap中的键相当于一个HashSet，需要重写equls和HashCode方法,保证键唯一

        使用HashSet存储元素的时候，底层是把元素存到Map中的键里面

JDK9中的新特性：添加元素到集合的of方法：
        在List，Map,Set接口中定义了一些重载的静态方法of可以实现将多个元素添加到集合中。
        注意事项：
                1.只能使用接口调用这些静态方法，实现类去调用则不可以
                2.使用of方法添加的元素不可被改变

集合和数组的区别：
        集合;长度可变，只能存储引用数据类型
        数组：长度固定，既可以存储基本数据类型，也可以存储引用数据类型

集合的体系结构：集合类有很多，不断地抽取共性，则形成了体系结构
        只要是Collection的实现类，则一定拥有Collection的方法
        Collection
            --List:有序（存和取的顺序），有索引，允许重复
                常用方法：
                        c.add("ad");//添加指定元素，返回是否添加成功
                        c.clear();//删除集合中的所有元素
                        c.contains("ad");//判断集合中是否包含指定元素
                        c.isEmpty();//判断集合是否为空（元素的个数是否为0）
                        c.remove("ad");//删除指定元素第一个出现的那个，返回是否删除功能（当元素不存在则删除失败）
                        c.size();//返回元素个数
                        c.toArray();//将集合转为数组
                --ArrayList
                --LinkedList
                --Vector
            --Set：无序（不保证存和取的顺序一致），无索引，不允许重复
                --HashSet
                    --LinkedHashSet
                --TreeSet
        Iterator:迭代器借口：
                boolean hasNext() 判断是否还有元素可以进行迭代
                E next（） 取出指定元素
                工作原理：
                        1.默认迭代器对象会指向集合的第一个元素，
                        2.可以先通过hasNext判断是否有指向位置的元素，如果有元素，则返回true
                        3.如果有元素，则可以通过next方法取出指定位置的元素
                注意事项：使用迭代器时，不能在使用过程中进行集合元素的添加或者删除

                解决并发修改异常：（略）
                        1.不要使用迭代器来遍历集合，使用转数组的方式
                        2.在需要修改集合的时候，不使用集合，用迭代器操作
                        ListIterator<String> it = c.listIterator//只有list中才能使用

增强for循环（foreach）:
        格式：
            for（元素类型 变量名 ：数组/集合） {}
        工作原理：
                每次都会将集合的元素赋值个冒号左边的变量，我们就可以通过操作变量从而操作集合中的元素
泛型
        使用泛型的好处：
                1.限定了集合中存储的数据类型，减少因为类型转换带来的一些问题
                2.简化代码的书写，可以不用向下转型
        定义泛型类：
                在定义类的时候在类名后声明泛型，当我们创建
                class Box<E>{}
        定义泛型接口：
                1.在定义实现类的时候，直接确定借口中的泛型具体类型
                        interface Box<E>{        }
                        class BoxImpl implements Box<String> {        }
                2.在定义实现类的时候不确定泛型的类型，但是在创建实现类对象的时候再去确定其具体类型
                        interface Box<E> {        }
                        class BoxImpl<E> implemrnts Box<E> {        }
                        BoxImpl<String> b = new BoxImpl<String>()
                泛型的边界：
                        1.？是一个通配符，如果泛型定义的类型是？代表可以传递任意类型的数据
                                public static void method(ArrayList<?> list) {        }
                        2.? extents Person 代表可以传递Person类型，以及其子类型
                                public static void method(ArrayList<? extents Person> list) {        }
                        3.? super Person 代表可以传递Person类型，以及其父类型
                                public static void method(ArrayList<? super Person> list) {        }

数据结构：
        栈：先进后出
           特点：
                1.只能在一端进行元素的添加和删除
                2.先进后出（*
                        入口和出口在同一侧，先进去的元素后出来
        队列：
           特点：
                1.先进先出（*）       
                2.入口和出口分别在两端
        数组：
           特点：
                1.增删慢：长度不可变
                2.查询快：元素有对应的索引，是一片连续的内存空间
        链表结构:
                每个元素都是一个对象，对象中包含的元素数据，指针每个元素之间，通过指针相连
           单向链表特点：
                1.增删快：增删元素不会改变原有内容
                2.查询慢：查询只能依次查询
           双向链表：
                相比单向链表：查询稍微快一点
        红黑树：
           特点：
                查询速度快
           名词解释：
                二叉树：分支不超过两个
                查找树/排序树：是一个有序的二叉树（左子树小于节点，右子树大于节点）左中右，则是从小到大的顺序
                平衡树：左右子树高度差不超过1
                红黑树：趋近于平衡树，查询速度非常快
        java.uitl.List
                概述：
                    是Collection下的一个子接口，在list接口下的集合都有以下特点
                        1.有序
                        2.右索引
                        3.允许重复
                List中的特有功能（和索引相关的增删改查的功能）
                        add(int index,E element):在指定索引位置添加元素
                        remove(int index):删除指定位置的元素，吧被删除的元素返回
                        set(int index, E element):修改指定索引位置的元素为指定值，把被修改的元素返回
                        get(int index):获取指定索引位置的元素

                Arraylist:底层实现的数组
                LinkedList：
                        1.底层是一个链表结构：查询慢，增删快
                        2.里边包含了大量操作首尾元素的方法
                        注意：使用LinkedList集合特有的方法，不能使用多态
                        addFirst(E e):将制定元素插入此列表的开头
                        addLast(E e):将制定元素添加到此列表的结尾
                        push(E e):将元素推入此列表所表示的堆栈

                        getFirst():返回此列表的第一元素
                        getLast():返回此列表的最后一个元素

                        removeFirst():移除并返回此列表的第一元素
                        removeLast():移除并返回此列表的最后一个元素
                        pop():从此列表所表示的堆栈处弹出一个元素
                        isEmpty():如果列表不包含元素，则返回true
                                可以模拟栈和队列
                Vector：
                        和ArrayList实现功能是一致的（底层也是数组的实现）
                        唯一的区别：
                                ArrayList不同步的（效率高，安全性低）
                                Vector

        Set接口的特点：
                1.不允许存储重复的元素
                2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
               
        HashSet的特点：
                底层是hash表的实现，查询的效率非常高
                1.不允许存储重复的元素
                2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
                3.是一个无序的集合，存储元素和取出元素的顺序有可能不一致
                4.可以使用迭代器和增强for循环遍历
        哈希值：
                默认情况：根据对象的物理地址算出索引位置
        HashSet的存储原理：
                通过hashCode方法确定索引位置
                再通过equals方法去除重复元素
                总结：
                     存储元素的操作：
                        1.先获取对象的hash值去存储元素
                                hash值不一样，直接存储
                                hash值一样
                                   则比较equals的返回值
                                        如果是true则认为元素重复
                                        如果false，则认为元素不重复，则添加元素
                当我们用HashSet存储自定义对象的时候，如果想保证元素的唯一性，则需要重写hashCode和equals方法
                        alt + insert
        LinkedHashSet:本质就是一个有序的HashSet：hash表+链表
                        hash表用于存储元素
                        链表用于记录元素存储的顺序，当我们获取元素的时候，则会通过链表记录的顺序去获取元素
        可变参数：
           一种特殊的参数类型，可以接受任意多个同种数据类型的数据：0个，1个···此类型的数组

                格式：
                        数据类型...参数名
                原理：
                        将传毒的任意多个元素，封装到一个数组中，最后再传递给可变参数的变量
        1.Comparator 比较器对象，一个额外的比较规则
       
        格式
        Collections.sort(arr, new Comparator<JiHeLei>() {
            @Override
            public int compare(JiHeLei o1, JiHeLei o2) {
                return o1.getAge()- o2.getAge();
            }
        });
        2.Comparable 让对象所在的类去实现，实现后，则可以使用sort方法实现对元素的排序
                在调用Collections.sort方法的时候，除了传递被排序的集合，还传递一个比较器实现类对象


去重复的原理：
        1.首先通过元素hashCode方法获取哈希值，计算出元素在哈希表中的位置
        2.如果对应位置已经有元素了，通过equals比较元素的内容
               
        HashSet存储自定义对象，元素所在的类必须重写hashCode和equals方法


java.utli.Map(k,v)

Map集合
        特点：
                1. 每个元素有键值对组成
                2. key不可重复，value可以重复
                   3. 可以通过key找到对应的值value
        Map的实现类介绍

                HashMap：底层是哈希表的实现（HashMap中的键其实就是HashSet）
                   LinkedHashMap  就是一个有序的HashMap
                   put方法添加元素，如果键不存在，直接添加，put方法返回null


                Hashtable
                        Properties

        比较：
           Hashtable是同步的，Hashtable不允许null键和null值
           HashMap是不同步的，HashMap允许null键和null值，但是null键只能出现一次

        Map的常用方法/功能：
                V put（K k，V v）添加元素，如果键已经存在则用新值替换旧值，并返回旧值
                V remove（K k）按照给定的删除整个键值对，并且返回被删除的值
                V get（Object key）获取指定键对应的值（通过建获取值）
                boolean containsKey（Object key）判断指定的键是否存在
                boolean containsValue（Object value）判断指定的值是否存在

        Map的常用遍历方法/功能：
                Set<K> keySet() 获取包含所有键的Set集合  其实HashMap中的键就相当于一个HashSet (键找值的方式遍历Map集合)
                        Set<String> keys = map.keySet();
                Set<Map.Entry<K,V>> entrySet() 获取所有包含键值对元素（Entry）的Set集合
                        Set<Map.Entry<String,String>> set = map.entrySet();
        用HashMap存储自定义对象
                由于HashMap中的键相当于一个HashSet，需要重写equls和HashCode方法,保证键唯一

        使用HashSet存储元素的时候，底层是把元素存到Map中的键里面

JDK9中的新特性：添加元素到集合的of方法：
        在List，Map,Set接口中定义了一些重载的静态方法of可以实现将多个元素添加到集合中。
        注意事项：
                1.只能使用接口调用这些静态方法，实现类去调用则不可以
                2.使用of方法添加的元素不可被改变