1、Collection

    • 集合知识回顾
      • 集合类的特点：提供了一种存储空间可变的存储模型，存储的数据容量可以随时发生改变
    • 集合类体系结构

    image.png

    • Collection集合概述和使用

      • Collection集合概述
        • 单例集合的顶层接口，表示一组对象，这些对象也称为Collection的元素
        • JDK不提供此接口的任何直接实现，它提供了更具体的子接口（如Set和List）实现
      • 创建Collection集合的对象
        • 多态的方式
        • 具体的实现类ArrayList 如 Collection c = new ArrayList();

    • Collection集合的常用方法 | 方法名 | 说明 | | —- | —- | | boolean add(E e) | 添加元素 | | boolean remove(Object o) | 从集合中移除指定的元素 | | void clear() | 清空集合中的元素 | | boolean contains(Object o) | 判断集合中是否存在指定的元素 | | boolean isEmpty() | 判断集合是否为空 | | int size() | 集合的长度，集合中元素的个数 |

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    4. /*
    5.     测试Collection集合的常用方法
    6.  */
    7. public class CollectionTest {
    8.     public static void main(String[] args) {
    9.         //创建对象
    10.         Collection<String> c = new ArrayList<String>();
    11.         c.add("窝");
    12.         c.add("嫩");
    13.         c.add("蝶");
    14.         System.out.println(c);
    16.         c.remove("窝");
    17.         System.out.println(c);
    19.         c.clear();
    20.         System.out.println(c);
    22.         c.add("窝");
    23.         boolean j = c.contains("窝");
    24.         System.out.println(j);
    25.     }
    26. }

    • Collection集合的遍历

      • Iterator：迭代器，集合专用的遍历方式
        • Iterator iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        • 迭代器是通过集合的iterator()方法得到的，所以说他是依赖于集合而存在的

      • Iterator中的常用方法

        • E next()：返回迭代中的下一个元素

        • boolean hasNext()：如果迭代具有更多的元素，则返回true

          1. public class CollectionIterator {
          2. public static void main(String[] args) {
          3. //创建Collection集合对象
          4. Collection<String> c = new ArrayList<>();
          5. c.add("窝");
          6. c.add("嫩");
          7. c.add("蝶");
          9. //创建Collection迭代器
          10. Iterator<String> i = c.iterator();
          11. while(i.hasNext()) {
          12.     System.out.println(i.next());
          13. }
          14. }
          15. }

    • 集合的使用步骤

      • image.png

    2、List

    • List集合概述和特点
      • List集合概述
        • 有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素。
        • 与Set集合不同，列表通常允许重复的元素
      • List集合特点
        • 有序：存储和取出的元素顺序一致
        • 可重复：存储的元素可以重复
    • List集合特有方法 | 方法名 | 说明 | | —- | —- | | void add(int index, E element) | 在此集合中的指定位置插入指定的元素 | | E remove(int index) | 删除指定索引处的元素，返回被删除的元素 | | E set(int index, E element) | 修改指定索引处的元素，返回被修改的元素 | | E get(int index) | 返回指定索引处的元素 |
    1. public class StudentList {
    2.     public static void main(String[] args) {
    3.         //创建List对象
    4.         List<Student> list = new ArrayList<>();
    6.         //创建学生对象
    7.         Student s1 = new Student("王小恒", 19);
    8.         Student s2 = new Student("王中恒", 20);
    9.         Student s3 = new Student("王大恒", 22);
    11.         list.add(s1);
    12.         list.add(s2);
    13.         list.add(s3);
    15.         //for循环进行遍历
    16.         for (int i = 0; i < list.size(); i++) {
    17.             Student s = list.get(i);
    18.             s.show();
    19.         }
    21.         //迭代器遍历
    22.         Iterator<Student> it = list.iterator();
    23.         while (it.hasNext()) {
    24.             it.next().show();
    25.         }
    27.         //增强for遍历
    28.         for(Student student : list) {
    29.             student.show();
    30.         }
    31.     }
    32. }

    • 并发修改异常

      • 并发修改异常
        • ConcurrentModificationException
      • 产生原因
        • 迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致
      • 解决方案
        • 用for循环遍历，然后用集合对象做对应的操作即可

    • ListIterator

      • ListIterator：列表迭代器
        • 通过List集合的listIterator()方法得到，这是List集合特有的迭代器
        • 用于沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
      • ListIterator中的常用方法
        • E next()：返回迭代中的下一个元素
        • boolean hasNext()：如果迭代具有更多的元素，返回true
        • E previous()：返回列表中的上一个元素
        • boolean hasPrevious()：如果列表迭代器在相反方向遍历列表时具有更多元素，则返回true
        • void add(E e)：将指定的元素插入列表

    • 增强for循环

      • 增强for：简化数组和Collection集合的遍历
        • 实现Iterable接口的类允许其对象称为增强型for语句的目标
        • JDK5之后出现的，内部原理是一个Iterator迭代器

      • 增强for的格式

        • 格式：

          • for(元素数据类型 变量名 : 数组或者Collection集合) {

            1.                  //在此处使用变量即可，改变量就是元素<br />                             {

        • 例如：

          • int[] arr = {1, 2, 3, 4, 5};

            1.              for(int i : arr) {<br />   System.out.println(i);<br />}

    • 数据结构

      • 数据结构就是计算机存储、组织数据的形式
      • 相互之间存在一种或多种特定关系的数据元素的集合
      • 通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率
      • 常见数据结构之栈
        • 先进后出
      • 常见数据结构之队列
        • 先进先出
      • 常见数据结构之数组
        • 查询快，增删慢
      • 常见数据结构之链表
        • 增删快，查询慢

    • List集合子类特点

      • List集合常用子类：ArrayList，LinkedList
        • ArrayList：底层数据结构是数组，查询快，增删慢
        • LinkedList：底层数据结构是链表，查询慢，增删快
      • LinkedList集合的特有功能 | 方法名 | 说明 | | —- | —- | | public void addFirst(E e) | 在该列表开头插入指定的元素 | | public void addLast(E e) | 将指定的元素追加到此列表的末尾 | | public E getFirst() | 返回此列表中的第一个元素 | | public E getLast() | 返回此列表中的最后一个元素 | | public E removeFirst() | 从此列表中删除并返回第一个元素 | | public E removeLast() | 从此列表中删除并返回最后一个元素 |