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

## 集合的体系结构：
        * 概述：集合类有很多，不断的抽取共性，则形成了体系结构
        * 结构：
            Collection
                |-- List : 有序（存和取的顺序），有索引，允许重复
                    |-- ArrayList
                    |-- LinkedList
                    |-- Vector
                |-- Set：无序（不保证存和取的顺序一致），无索引，不允许重复
                    |-- HashSet
                        |-- LinkedHashSet
                    |-- TreeSet

## Collection中的常用功能：
        * 常用功能
            boolean add(E e) 添加指定元素，返回是否添加功能
            void clear() 删除集合中所有元素（清空）
            boolean contains(Object o) 判断集合中是否包含指定元素
            boolean isEmpty() 判断集合是否为空（元素的个数是否为0）
            boolean remove(Object o) 删除指定元素第一次出现的那个，返回是否删除功能（当元素不存在则删除失败）
            int size() 返回元素的个数
            Object[] toArray() 将集合转为数组
            T[] toArray(T[] arr) 将集合转为指定类型的数组
       
            Iterator<E> iterator() 返回一个迭代器对象
## Iterator：迭代器接口：
        boolean hasNext() 判断是否还有元素可以迭代
        E next() 取出指定元素

        工作原理：
            1. 默认迭代器对象会指向集合的第一个元素
            2. 我们可以先通过hasNext判断是否有指向位置的元素，如果有元素，则返回true
            3. 如果有元素，则可以通过next方法取出指定位置的元素
        注意事项：
            1. NoSuchElementException 没有指定元素异常
                解释：
                    当迭代器遍历到集合的末尾已经没有元素可以遍历了，如果还调用next方法获取元素，则抛出此异常
            2. ConcurrentModificationException 并发修改异常
                当我们在使用迭代器进行集合元素遍历的时候，如果此时我们对集合的元素进行了添加或者删除，则会导致遍历的结果不确定，则抛出此异常
                记住：
                    我们使用迭代器的时候，不要在使用过程中进行集合元素的添加或者删除

                想解决这个并发修改异常：（略）
                    1. 不要使用迭代器来遍历集合，使用转数组的方式
                    2. 在需要修改集合的时候，不要使用集合去操作，使用迭代器操作

## 增强for循环（foreach）：
        * 格式：
            for(元素类型 变量名 : 数组/集合){

            }
        * 工作原理：
            每次都会将数组/集合的元素赋值给左边的变量，我们就可以通过操作变量从而操作集合中的元素

        * 注意：
                        * 由于增强for的底层使用的是迭代器，所以不能在增强for中使用集合添加或者删除元素


## 泛型：
    * 使用泛型好处:
        1. 限定了集合中存储的数据类型，减少因为类型转换带来的一些问题（提高了安全性）
        2. 简化代码的书写，可以不用向下转型

    * 定义泛型类：
        在定义类的时候在类名后声明泛型：当我们创建此类对象的时候，确定泛型具体是什么类型
        class Box<E> {
        }

    * 定义泛型方法：
        应用场景：如果返回值类型和传递的参数是相关的，这个时候推荐使用泛型方法
        public <E> E getElement(ArrayList<E> list, int index){
        }

    * 定义泛型接口
        1. 在定义实现类的时候，直接确定接口中的泛型具体类型
            interface Box<E> {
            }
            class BoxImpl implements Box<String> {
            }

        2. 在定义实现类的时候不确定泛型的类型，但是在创建实现类对象的时候再去确定其具体类型
            interface Box<E> {
            }
            class BoxImpl<E> implements Box<E> {
            }
            BoxImpl<String> b = new BoxImpl<String>()

    * 泛型的边界：
        1. ? 是一个通配符，如果泛型定义的类型是?代表可以传递任意类型的数据
        2. ? extends Person  代表可以传递Person类型，以及其子类型
        3. ? super Person  代表可以传递Person类型，以及其父类型
    数组：长度固定，既可以存基本类型也可以存引用类型

## 集合的体系结构：
        * 概述：集合类有很多，不断的抽取共性，则形成了体系结构
        * 结构：
            Collection
                |-- List : 有序（存和取的顺序），有索引，允许重复
                    |-- ArrayList
                    |-- LinkedList
                    |-- Vector
                |-- Set：无序（不保证存和取的顺序一致），无索引，不允许重复
                    |-- HashSet
                        |-- LinkedHashSet
                    |-- TreeSet

## Collection中的常用功能：
        * 常用功能
            boolean add(E e) 添加指定元素，返回是否添加功能
            void clear() 删除集合中所有元素（清空）
            boolean contains(Object o) 判断集合中是否包含指定元素
            boolean isEmpty() 判断集合是否为空（元素的个数是否为0）
            boolean remove(Object o) 删除指定元素第一次出现的那个，返回是否删除功能（当元素不存在则删除失败）
            int size() 返回元素的个数
            Object[] toArray() 将集合转为数组
            T[] toArray(T[] arr) 将集合转为指定类型的数组
       
            Iterator<E> iterator() 返回一个迭代器对象
## Iterator：迭代器接口：
        boolean hasNext() 判断是否还有元素可以迭代
        E next() 取出指定元素

        工作原理：
            1. 默认迭代器对象会指向集合的第一个元素
            2. 我们可以先通过hasNext判断是否有指向位置的元素，如果有元素，则返回true
            3. 如果有元素，则可以通过next方法取出指定位置的元素
        注意事项：
            1. NoSuchElementException 没有指定元素异常
                解释：
                    当迭代器遍历到集合的末尾已经没有元素可以遍历了，如果还调用next方法获取元素，则抛出此异常
            2. ConcurrentModificationException 并发修改异常
                当我们在使用迭代器进行集合元素遍历的时候，如果此时我们对集合的元素进行了添加或者删除，则会导致遍历的结果不确定，则抛出此异常
                记住：
                    我们使用迭代器的时候，不要在使用过程中进行集合元素的添加或者删除

                想解决这个并发修改异常：（略）
                    1. 不要使用迭代器来遍历集合，使用转数组的方式
                    2. 在需要修改集合的时候，不要使用集合去操作，使用迭代器操作

## 增强for循环（foreach）：
        * 格式：
            for(元素类型 变量名 : 数组/集合){

            }
        * 工作原理：
            每次都会将数组/集合的元素赋值给左边的变量，我们就可以通过操作变量从而操作集合中的元素

        * 注意：
                        * 由于增强for的底层使用的是迭代器，所以不能在增强for中使用集合添加或者删除元素


## 泛型：
    * 使用泛型好处:
        1. 限定了集合中存储的数据类型，减少因为类型转换带来的一些问题（提高了安全性）
        2. 简化代码的书写，可以不用向下转型

    * 定义泛型类：
        在定义类的时候在类名后声明泛型：当我们创建此类对象的时候，确定泛型具体是什么类型
        class Box<E> {
        }

    * 定义泛型方法：
        应用场景：如果返回值类型和传递的参数是相关的，这个时候推荐使用泛型方法
        public <E> E getElement(ArrayList<E> list, int index){
        }

    * 定义泛型接口
        1. 在定义实现类的时候，直接确定接口中的泛型具体类型
            interface Box<E> {
            }
            class BoxImpl implements Box<String> {
            }

        2. 在定义实现类的时候不确定泛型的类型，但是在创建实现类对象的时候再去确定其具体类型
            interface Box<E> {
            }
            class BoxImpl<E> implements Box<E> {
            }
            BoxImpl<String> b = new BoxImpl<String>()

    * 泛型的边界：
        1. ? 是一个通配符，如果泛型定义的类型是?代表可以传递任意类型的数据
        2. ? extends Person  代表可以传递Person类型，以及其子类型
        3. ? super Person  代表可以传递Person类型，以及其父类型

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

## 集合的体系结构：
        * 概述：集合类有很多，不断的抽取共性，则形成了体系结构
        * 结构：
            Collection
                |-- List : 有序（存和取的顺序），有索引，允许重复
                    |-- ArrayList
                    |-- LinkedList
                    |-- Vector
                |-- Set：无序（不保证存和取的顺序一致），无索引，不允许重复
                    |-- HashSet
                        |-- LinkedHashSet
                    |-- TreeSet

## Collection中的常用功能：
        * 常用功能
            boolean add(E e) 添加指定元素，返回是否添加功能
            void clear() 删除集合中所有元素（清空）
            boolean contains(Object o) 判断集合中是否包含指定元素
            boolean isEmpty() 判断集合是否为空（元素的个数是否为0）
            boolean remove(Object o) 删除指定元素第一次出现的那个，返回是否删除功能（当元素不存在则删除失败）
            int size() 返回元素的个数
            Object[] toArray() 将集合转为数组
            T[] toArray(T[] arr) 将集合转为指定类型的数组
       
            Iterator<E> iterator() 返回一个迭代器对象
## Iterator：迭代器接口：
        boolean hasNext() 判断是否还有元素可以迭代
        E next() 取出指定元素

        工作原理：
            1. 默认迭代器对象会指向集合的第一个元素
            2. 我们可以先通过hasNext判断是否有指向位置的元素，如果有元素，则返回true
            3. 如果有元素，则可以通过next方法取出指定位置的元素
        注意事项：
            1. NoSuchElementException 没有指定元素异常
                解释：
                    当迭代器遍历到集合的末尾已经没有元素可以遍历了，如果还调用next方法获取元素，则抛出此异常
            2. ConcurrentModificationException 并发修改异常
                当我们在使用迭代器进行集合元素遍历的时候，如果此时我们对集合的元素进行了添加或者删除，则会导致遍历的结果不确定，则抛出此异常
                记住：
                    我们使用迭代器的时候，不要在使用过程中进行集合元素的添加或者删除

                想解决这个并发修改异常：（略）
                    1. 不要使用迭代器来遍历集合，使用转数组的方式
                    2. 在需要修改集合的时候，不要使用集合去操作，使用迭代器操作

## 增强for循环（foreach）：
        * 格式：
            for(元素类型 变量名 : 数组/集合){

            }
        * 工作原理：
            每次都会将数组/集合的元素赋值给左边的变量，我们就可以通过操作变量从而操作集合中的元素

        * 注意：
                        * 由于增强for的底层使用的是迭代器，所以不能在增强for中使用集合添加或者删除元素


## 泛型：
    * 使用泛型好处:
        1. 限定了集合中存储的数据类型，减少因为类型转换带来的一些问题（提高了安全性）
        2. 简化代码的书写，可以不用向下转型

    * 定义泛型类：
        在定义类的时候在类名后声明泛型：当我们创建此类对象的时候，确定泛型具体是什么类型
        class Box<E> {
        }

    * 定义泛型方法：
        应用场景：如果返回值类型和传递的参数是相关的，这个时候推荐使用泛型方法
        public <E> E getElement(ArrayList<E> list, int index){
        }

    * 定义泛型接口
        1. 在定义实现类的时候，直接确定接口中的泛型具体类型
            interface Box<E> {
            }
            class BoxImpl implements Box<String> {
            }

        2. 在定义实现类的时候不确定泛型的类型，但是在创建实现类对象的时候再去确定其具体类型
            interface Box<E> {
            }
            class BoxImpl<E> implements Box<E> {
            }
            BoxImpl<String> b = new BoxImpl<String>()

    * 泛型的边界：
        1. ? 是一个通配符，如果泛型定义的类型是?代表可以传递任意类型的数据
        2. ? extends Person  代表可以传递Person类型，以及其子类型
        3. ? super Person  代表可以传递Person类型，以及其父类型
    数组：长度固定，既可以存基本类型也可以存引用类型

## 集合的体系结构：
        * 概述：集合类有很多，不断的抽取共性，则形成了体系结构
        * 结构：
            Collection
                |-- List : 有序（存和取的顺序），有索引，允许重复
                    |-- ArrayList
                    |-- LinkedList
                    |-- Vector
                |-- Set：无序（不保证存和取的顺序一致），无索引，不允许重复
                    |-- HashSet
                        |-- LinkedHashSet
                    |-- TreeSet

## Collection中的常用功能：
        * 常用功能
            boolean add(E e) 添加指定元素，返回是否添加功能
            void clear() 删除集合中所有元素（清空）
            boolean contains(Object o) 判断集合中是否包含指定元素
            boolean isEmpty() 判断集合是否为空（元素的个数是否为0）
            boolean remove(Object o) 删除指定元素第一次出现的那个，返回是否删除功能（当元素不存在则删除失败）
            int size() 返回元素的个数
            Object[] toArray() 将集合转为数组
            T[] toArray(T[] arr) 将集合转为指定类型的数组
       
            Iterator<E> iterator() 返回一个迭代器对象
## Iterator：迭代器接口：
        boolean hasNext() 判断是否还有元素可以迭代
        E next() 取出指定元素

        工作原理：
            1. 默认迭代器对象会指向集合的第一个元素
            2. 我们可以先通过hasNext判断是否有指向位置的元素，如果有元素，则返回true
            3. 如果有元素，则可以通过next方法取出指定位置的元素
        注意事项：
            1. NoSuchElementException 没有指定元素异常
                解释：
                    当迭代器遍历到集合的末尾已经没有元素可以遍历了，如果还调用next方法获取元素，则抛出此异常
            2. ConcurrentModificationException 并发修改异常
                当我们在使用迭代器进行集合元素遍历的时候，如果此时我们对集合的元素进行了添加或者删除，则会导致遍历的结果不确定，则抛出此异常
                记住：
                    我们使用迭代器的时候，不要在使用过程中进行集合元素的添加或者删除

                想解决这个并发修改异常：（略）
                    1. 不要使用迭代器来遍历集合，使用转数组的方式
                    2. 在需要修改集合的时候，不要使用集合去操作，使用迭代器操作

## 增强for循环（foreach）：
        * 格式：
            for(元素类型 变量名 : 数组/集合){

            }
        * 工作原理：
            每次都会将数组/集合的元素赋值给左边的变量，我们就可以通过操作变量从而操作集合中的元素

        * 注意：
                        * 由于增强for的底层使用的是迭代器，所以不能在增强for中使用集合添加或者删除元素


## 泛型：
    * 使用泛型好处:
        1. 限定了集合中存储的数据类型，减少因为类型转换带来的一些问题（提高了安全性）
        2. 简化代码的书写，可以不用向下转型

    * 定义泛型类：
        在定义类的时候在类名后声明泛型：当我们创建此类对象的时候，确定泛型具体是什么类型
        class Box<E> {
        }

    * 定义泛型方法：
        应用场景：如果返回值类型和传递的参数是相关的，这个时候推荐使用泛型方法
        public <E> E getElement(ArrayList<E> list, int index){
        }

    * 定义泛型接口
        1. 在定义实现类的时候，直接确定接口中的泛型具体类型
            interface Box<E> {
            }
            class BoxImpl implements Box<String> {
            }

        2. 在定义实现类的时候不确定泛型的类型，但是在创建实现类对象的时候再去确定其具体类型
            interface Box<E> {
            }
            class BoxImpl<E> implements Box<E> {
            }
            BoxImpl<String> b = new BoxImpl<String>()

    * 泛型的边界：
        1. ? 是一个通配符，如果泛型定义的类型是?代表可以传递任意类型的数据
        2. ? extends Person  代表可以传递Person类型，以及其子类型
        3. ? super Person  代表可以传递Person类型，以及其父类型