集合Collection(没有set)

1.对象数组

        (1)数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的 时候的数组就叫对象数组。

2.集合(Collection是集合的顶层接口，它的子体系有重复，有唯一，有有序，有无序)

        (1)集合的由来?

                我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组 和StringBuffer) -- 数组

                而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我 们使用。

        (2)集合和数组的区别?

                A:长度区别

                        数组固定

                        集合可变

                B:内容区别

                        数组可以是基本类型，也可以是引用类型

                        集合只能是引用类型

                C:元素内容

                        数组只能存储同一种类型

                        集合可以存储不同类型(其实集合一般存储的也是同一种类型)

        (3)集合的继承体系结构?

                由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，

                我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。

        Collection

                        |--List

                                |--ArrayList

                                |--Vector

                                |--LinkedList

                      |--Set

                                |--HashSet

                                |--TreeSet

        (4)Collection的功能概述

                Boolean isEmpty()

                A:添加功能

                        boolean add(E e):添加一个元素

                        boolean addAll(Collection<? extends E> c):添加一个集合的元素

                B:删除功能

                        void clear()：移除所以元素

                        boolean remove(E e):移除一个元素

                        boolean removeAll(Collection c): 移除一个集合的元素(只要有一个元素被移除，就返回true)

                C:判断功能

                        boolean contains(E e):判断集合中是否包含指定的元素

                       Boolean contains(Collection<?> c):判断集合中是否包含指定的集合元素（是一个还是所有 只有包含所有的元素才叫包含）

                D:获取功能

                        Iterator<E> iterator()

                E:长度功能

                        Int size():元素的个数

                F:交集

                        Boolean retainAll(Collection c):两个集合都有的元素？元素去哪了，返回的Boolean是什么意思。

        假设有AB两个集合，A对B做交集，最终结果保存在A中，B不变。返回值表示A是否发生改变。

                G:把集合转数组

                        Object[] toArray()

        (5)Collection集合的遍历

                A:把集合转数组Object[] toArray()

                B:迭代器(集合专用方式)Iterator iterator()

        (6)迭代器

                A:是集合的获取元素的方式。

                Object next():获取元素，并移动到下一个位置

                Boolean hasNext():如果仍有元素可以迭代，则返回true

                B:是依赖于集合而存在的。

                C:迭代器的原理和源码。

                        a:为什么定义为了一个接口而不是实现类?

 

         (7)Collection集合的案例(遍历方式 迭代器)

                集合的操作步骤：

                        A:创建集合对象

                        B:创建元素对象

                        C:把元素添加到集合

                        D:遍历集合

3:集合(List)

        (1)List是Collection的子接口

                特点：有序(存储顺序和取出顺序一致)，可重复。

        (2)List的特有功能：

                A:添加功能

                        Void add(int index,E element):在指定位置添加元素

                B:删除功能

                        E remove(int index):根据索引删除元素，返回被删除的元素

                C:获取功能

                        E get(int index):获取指定位置的元素

                D:迭代器功能(列表迭代器)

                        ListIterator<E> listIterator():List集合特有的迭代器

                E:修改功能

                        E set(int index,e element):根据索引修改元素，返回被修改的元素

        (3)List集合的特有遍历功能

                A:由size()和get()结合。

        (5)列表迭代器的特有功能；

                E previous():获取上一个元素

                boolean hasNext()：判断是否有元素

                可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。

        (6)并发修改异常ConcurrentModificationException

                A:出现的现象

                        迭代器遍历集合，集合修改集合元素

                B:原因

                        迭代器是依赖于集合的，而集合的改变迭代器并不知道。

                C:解决方案

                        a:迭代器遍历，迭代器修改(ListIterator)

                                元素添加在刚才迭代的位置

                        b:集合遍历，集合修改(size()和get())

                                元素添加在集合的末尾

        (7)常见数据结构

                A:栈 先进后出

                B:队列 先进先出

                C:数组 存储同一种类型的多个元素的容器。有索引，查询快，增删慢

                D:链表 由一个链子把多个节点连起来组成的数据。结点有数据和地址组成（数据域和指针域组成）查询慢，增删快

                把第一元素给最后一个元素的地址位置，就是循环链表

                每个节点由三部分组成，就是双向链表

                E:树

                F:哈希表

        (8)List的子类特点

                ArrayList

                        底层数据结构是数组，查询快，增删慢。

                        线程不安全，效率高。

                Vector

                        底层数据结构是数组，查询快，增删慢。

                        线程安全，效率低。

                LinkedList           

                        底层数据结构是链表，查询慢，增删快。

                        线程不安全，效率高。

                到底使用谁呢?看需求?

                        分析：

                                要安全吗?

                                        要：Vector(即使要，也不使用这个，后面再说)

                                        不要：ArrayList或者LinkedList

                                                查询多；ArrayList

                                                增删多：LinkedList

                        什么都不知道，就用ArrayList。

        (9)ArrayList

                A:没有特有功能需要学习

        (10)Vector

                A:有特有功能

                        a:添加

                public void addElement(E obj) -- add()

                        b:获取

                public E elementAt(int index) -- get()

                public Enumeration<E> elements() --  iterator()

        (11)LinkedList

                A:有特有功能

                        a:添加

                                addFirst()

                                addLast()

                        b:删除

                                removeFirst()

                                removeLast()

                        c:获取

                                getFirst()

                                getLast()

4.静态导入

        (1)可以导入到方法级别的导入

        (2)格式：

                import static 包名....类名.方法名;

         (3)注意事项：

                A:方法必须是静态的

                B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。

                        所以一般我们并不使用静态导入，但是一定要能够看懂。

5.可变参数

        (1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。

        (2)格式：

                修饰符 返回值类型 方法名(数据类型... 变量) {}

                注意：

                        A:该变量其实是一个数组名

                        B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后

        (3)Arrays工具类的一个方法

                asList()把数组转成集合。

                public static <T> List <T> asList(T...a)把数组转成集合

                注意：这个集合的长度不能改变