2021-04-21集合

集合

集合类体系结构

结构图.png

Collection集合概述和使用

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

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo01 {
    public static void main(String[] args) {
        // 创建Collection集合的对象
        Collection c = new ArrayList();

        // 添加元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("Java");
        // 输出对象
        System.out.println(c);
    }
}

代码运行截图.png

Collection集合常用方法

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

小tips:
若要查询源码：按住Ctrl+B跟进，使用Alt+7，可以打开一个窗口，能够看到类的所有信息

public class CollectionDemo01 {
    public static void main(String[] args) {
        // 创建Collection集合的对象
        Collection c = new ArrayList();
        // 添加元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("Java");
        // 输出对象
        System.out.println(c.add("nihao"));
        System.out.println(c);
        System.out.println(c.size());
        System.out.println(c.remove("world"));
        System.out.println(c.remove("sss"));
        System.out.println(c);
        System.out.println(c.contains("hello"));
        c.clear();
        System.out.println(c);  // []
        System.out.println(c.isEmpty()); // true
    }
}

Collection集合的遍历

Iterator:迭代器，集合的专用遍历方式

Iterator iterator(): 返回此集合中元素的迭代器，通过集合的iterator()方法得到
迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的
Iterator中的常用方法
E next(): 返回迭代中的下一个元素
boolean hasNext(): 如果迭代具有更多的元素，则返回true

public class IteratorDemo {
    public static void main(String[] args) {
// 创建集合对象
        Collection c = new ArrayList();
// 添加元素到集合
        c.add("hello");
        c.add("world");
        c.add("java");
//  通过集合对象获取迭代器对象
        Iterator it = c.iterator();
        /*
          * public Iterator iterator() {
                 return new Itr();
            }
          *
          * private class Itr implements Iterator {
          * }
          * */
        /*
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());  // NoSuchElementException :表示被请求的元素不存在。
        */
       // 用while循环改进判断
        while (it.hasNext()) {      // 通过迭代器对象的hasNext()方法判断是否还有元素
//            System.out.println(it.next());
            String s = it.next();   // 通过迭代器对象的next()方法获取下一个元素
            System.out.println(s);
        }
    }
}

代码运行结果.png

案例：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

定义一个学生类：
public class Student {

    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        Student s1 = new Student("张曼玉",30);
        Student s2 = new Student("林青霞",36);
        Student s3 = new Student("张敏",32);
        // 把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        // 遍历集合(迭代器方式)
        Iterator it = c.iterator();
        while(it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getAge()+","+s.getName());
        }

    }
}

代码运行结果.png

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)	返回指定索引处的元素

演示如下：

public class ListDemo01 {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("Java");

        // 输出集合对象
//        System.out.println(list);
        //  迭代器的方式遍历
        list.add(2, "heima");
        System.out.println(list);
        System.out.println(list.remove(1));
        System.out.println(list.set(2, "javaee"));
        System.out.println(list.get(2));
        System.out.println("-----");
//        System.out.println(list);
        // 遍历集合
//        System.out.println(list.get(0));
//        System.out.println(list.get(1));
//        System.out.println(list.get(2));
        // 用for循环改进
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }

    }
}

代码运行截图.png

遍历集合的两种方式（迭代器方式，for循环方式）

 for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName()+","+s.getAge());

        }
        System.out.println("-------");
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }

并发修改异常

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

ListIterator

listIterator:列表迭代器

通过list集合的listIterator()方法得到，所以说它是List集合特有的迭代器
用于允许程序员沿任一方向遍历列表的列表的迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。与Iterator迭代器（仅仅可以从前往后遍历）不同

ListIterator的常用方法

E next() : 返回迭代中的下一个元素
boolean hasNext() : 如果迭代具有更多元素，则返回true
boolean hasPrevious() : 如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
void add(E e) ：将指定的元素插入列表

ListIterator lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if(s.equals("world")) {
                lit.add("javase");
            }
        }
// 可以实现对列表的修改，避免出现并发修改异常
// 源码分析：
try        {
                int i = cursor;
                ArrayList.this.add(i, e);
                cursor = i + 1;
                lastRet = -1;
                expectedModCount = modCount;  // 把实际修改集合的字数赋值给预期修改集合的字数
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }

增强for循环

增强for:简化数组和Collection集合的遍历

实现Iterable接口的类允许其对象成为增强型for语句的目标
它是JDK5之后出现的，其内部原理是一个Iterator迭代器

增强for的格式：

格式：
for(元素数据类型变量名:数组或者Collection集合) {
// 在此处使用变量即可，该变量就是元素
}
范例：
int[] arr = {1,2,3,4,5};
for(int i : arr ) {
System.out.println(i);
}

 List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("timlony");
        for (String s : list) {
            System.out.println(s);
        }

for (Student s : list) {
            System.out.println(s.getName()+","+s.getAge());
        }

集合循环方式	区别
迭代器	集合特有的遍历方式
普通for	带有索引的遍历方式
增强for	最方便的遍历方式

数据类型.png

数据结构（B站视频av61085712 ___P235-236）

定义：是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合

常见的数据结构之栈

数据进入栈模型的过程称为：压/进栈
数据离开栈模型的过程称为：弹/出栈
栈是一种数据先进后出的模型

常见的数据结构之队列

数据从后端进入队列模型的过程称为：入队列
数据从前端进入队列模型的过程称为：出队列
队列是一种数据先进先出的模型

常见的数据结构之数组

数组是一种查询快，增删慢的模型
查询数据通过索引定位，查询任意数据耗时相同，查询效率高
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

常见的数据结构之链表

链表中的每个元素称为结点，结点的存储位置（地址）应该包含 1. 存储具体的数据、2.下一个结点的地址。
链表是一种增删快的模型（对比数组）
链表是一种查询慢的模型（对比数组）：需要从头开始查询

List集合子类特点：

List集合常用子类：ArrayList,LinkedList

ArrayList ：底层数据结构是数组，查询快，增删慢
LinkedList：底层数据结构是链表，查询慢，增删快
案例：使用ArrayList集合存储学生对象三种方式

public class ListDemo {
    public static void main(String[] args) {
        // 创建集合对象Arraylist
        ArrayList array = new ArrayList();
        Student s1 = new Student("林青霞", 32);
        Student s2 = new Student("张曼玉", 32);
        Student s3 = new Student("王祖贤", 31);

        array.add(s1);
        array.add(s2);
        array.add(s3);

        // 增强for:最方便的遍历方式
        for (Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");
        // 普通for:带有索引的遍历方式
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }

        // 迭代器，集合特有的遍历方式
        Iterator it = array.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

    }
}

LinkedList集合的特有功能

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素