Java集合-Collection集合体系概述

一、集合概述及集合框架

1. 对象数组

• 概述
  • 一个班级有多个学生，想存储学生的信息，现有一个已经封装好的学生类Student类，如果为每一个学生对象都创建一个变量，那么将会产生相当多的变量，变量的命名及每次变量的调用都会很麻烦，这时候我们就可以声明一个Student类型的数组，将每一个Student对象存储在数组中，调用时使用数组名和索引就可以了
  • 例如

 public static void main(String[] args) {
        //假设Student类是已经设计好的
        Student[] students = new Student[20];
        students[0] = new Student("张三", 17);
        students[1] = new Student("李四", 18);
        //等等，可以继续填下去
    }

• 数组存储数据的特点
  • 数据类型不限，基本数据类型和引用数据类型(对象)都可以
  • 数组的长度一经确定就不可更改
  • 只能存储同一数据类型的数据

2. 集合概述

• 概述
  • 与数组一样，集合也是存储和操作数据的一种容器，但集合允许存储不同的数据类型的数据，而且集合的长度可变
• 集合与数组的异同点
  • 长度
    • 集合长度可变，数组长度定义后就固定了
  • 存储的数据类型
    • 集合只能存储引用数据类型，数据基本类型和引用类型都可以
  • 存储的数据内容
    • 数组只能存储定义时声明的那种类型的数据，集合没有限制

3. 集合的继承体系图

• 集合的继承体系图
  

二、Collection集合

1. Collection集合概述

• Collection集合概述
  • Collection层次结构的根接口，Collection接口表示一组对象，这些对象也叫做Collection接口的元素。JDK并不直接提供此接口的实现，因为有更具体的子接口去实现，Collection接口通常只传递有最大普遍性的集合。

2. Collection集合的增删功能

• Collection集合的添加功能
  • boolean add(Object obj)
    • 向集合中添加一个元素，添加成功返回true，不成功返回false
  • boolean addAll(Collection c)
    • 将另一个集合中的元素添加进此集合中，添加成功返回true，不成功返回false
• Collection集合的删除功能
  • void clear()
    • 清空集合，将集合中的所有元素移除
  • boolean remove(Object o)
    • 移除一个元素
  • boolean removeAll (Collection c)
    • 移除与另一个集合的交集元素，移除一个以上返回true，没有交集元素则返回false

3. Collection集合的判断与获取功能

• Collection集合的判断功能

  • boolean contains(Object o)
    • 判断集合中是否包含指定元素
  • boolean containsAll(Collection c)
    • 判断集合是否包含另一个集合，全部包含返回true，否则返回false
  • boolean isEmpty()
    • 判断一个集合是否为空

• Collection集合的迭代器

  • Iterator iterator()
    • 返回在此集合上进行迭代的迭代器
  • 利用迭代器对集合遍历

public class Students {//简单学生类
    public String name = "";
    public int age = 0;//实例域
    
    public Students(String name, int age) {//构造方法
        this.name = name;
        this.age = age;
    }
}

public class StudentsTest1 {//测试类，利用迭代器对集合遍历
    public static void main(String[] args) {
        Collection stuCollection = new ArrayList();//定义集合
        stuCollection.add(new Students("张三", 18));
        stuCollection.add(new Students("李四", 20));
        stuCollection.add(new Students("王五", 25));//对集合进行赋值

        Iterator stuIterator = stuCollection.iterator();//定义迭代器

        while (stuIterator.hasNext()) {//遍历输出
            Object next = stuIterator.next();
            Students stu = (Students) next;
            System.out.println("姓名:" + stu.name + "\t年龄:" + stu.age);
        }
    }
}
//输出结果：
//姓名:张三	年龄:18
//姓名:李四	年龄:20
//姓名:王五	年龄:25

4. Collection集合的其他功能

• 长度功能
  • int size
    • 返回集合中的元素个数
• 求两个集合交集
  • boolean retainAll(Collection c)
    • 获取两个元素的交集，并将交集元素存储在调用方法的集合内，如果调用方法的集合元素发生变化，返回true
• 将集合转变为数组
  • Object[] toArray()
    • 将指定集合转换为数组

三、List集合

1. List集合概述

• 有序的集合，也称之为序列，序列中的每一个元素都有对应的索引，可以根据索引访问元素。List中允许出现重复的元素

2. List集合的特殊方法

• List集合继承自Collection集合，所以它可以使用Collection集合的公开方法，除此之外，List集合还有下列特有的方法

• void add(int index,E element)

  • 给指定的索引处添加指定的元素

• E get(int index)

  • 获取指定索引处的元素

• E remove(int index)

  • 删除指定索引处的元素，并将这个元素返回

• E set (int index,E element)

  • 使用指定的元素将指定索引处的元素替换，并将被替换的元素返回

• 利用size()和get()方法结合对列表进行遍历

public class StudentsTest2 {//使用size()和get()方法对列表进行遍历
    public static void main(String[] args) {
        List stuList = new ArrayList();//定义列表
        stuList.add(new Students("张三", 18));
        stuList.add(new Students("李四", 20));
        stuList.add(new Students("王五", 25));//对列表进行赋值

        for (int i = 0; i < stuList.size(); i++) {//遍历
            Object o = stuList.get(i);
            Students stu = (Students) o;
            System.out.println("姓名:" + stu.name + "\t年龄:" + stu.age);
        }
    }
}
//运行结果：
//姓名:张三	年龄:18
//姓名:李四	年龄:20
//姓名:王五	年龄:25

3. Listiterator

• 列表迭代器，允许按任一方向遍历列表，迭代期间修改列表，并获得迭代器在列表中的当前位置。长度为n的列表的迭代器有n+1个可能的位置，迭代器位于调用previous()方法返回的元素与调用next()方法所返回的元素之间
• ListIterator特有方法
  • boolean hasPrevious()
    • 如果以逆向遍历列表，如果前面还有多个元素，返回true
  • E previous()
    • 返回列表中的前一个元素
  • 注：上述两个方法可以实现对列表的反向遍历，但是在反向遍历之前，必须对列表进行一次正向遍历，让指针指向最后一个元素。直接进行反向遍历指针默认位于最前方，而此时指针的前方并没有元素
• 使用列表迭代器对列表进行遍历

public class StudentsTest3 {//利用列表迭代器对列表遍历
    public static void main(String[] args) {
        List stuList = new ArrayList();//定义列表
        stuList.add(new Students("张三", 18));
        stuList.add(new Students("李四", 20));
        stuList.add(new Students("王五", 25));//对列表进行赋值

        ListIterator stuListIterator = stuList.listIterator();//定义列表迭代器

        while (stuListIterator.hasNext()) {//先正向遍历将指针指向最后一个元素
            stuListIterator.next();
        }
        while (stuListIterator.hasPrevious()) {//从最后一个元素反向遍历
            Object previous = stuListIterator.previous();
            Students stu = (Students) previous;
            System.out.println("姓名:" + stu.name + "\t年龄:" + stu.age);
        }
    }
}
//运行结果：
//姓名:王五	年龄:25
//姓名:李四	年龄:20
//姓名:张三	年龄:18

4. 并发修改异常产生原因及解决方案

• 问题描述
  • 当我们采用Iterator迭代器对集合进行遍历时，如果在此过程中对原集合的元素进行增删等处理，就会产生并发修改异常
• 原因
  • 当我们给集合中添加完元素以后，采用Iterator迭代器对集合的元素进行遍历，此时迭代器已经得到了集合的原长度，如果在此时进行增删等操作，肯定会改变集合的长度，迭代器检测到集合长度发生变化，就会发生并发修改异常
• 解决方案
  • 使用ListIterator迭代器
    • ListIterator迭代器有自己的增删改查方法，采用ListIterator提供的方法。不会产生并发修改异常
  • 不使用迭代器遍历修改
    • 可以使用for循环和size()和get()方法遍历

四、常见几种数据结构

1. 栈和队列

• 栈
  • 先进栈的元素存放在栈底，后进栈的元素存放在栈顶，出栈时，栈顶元素先出栈
• 队列
  • 后进来的元素排在队尾，排在前面的元素先出队列，

2. 数组和链表

• 数组
  • 长度一经确认就不能更改，查询快，增删时要创建新的数组，故增删较慢
• 链表
  • 链表中的每一个元素都由数据域和地址域两部分组成，数据域存放节点所存放的数据，地址域存放下一节点的地址，用来将一个个节点链接起来

五、List集合的三个子类 ArrayList、Vector、LinkedList

1. ArrayList集合

• ArrayList 集合特点
  • 底层通过数组实现，查询快，增删慢
  • 线程不安全，效率快
• 特有方法
  • void forEach(Consumer<? super E> action)
    • ArrayList类自带的迭代器，可以对列表元素进行遍历
    • 将Consumer的匿名内部类作为参数传递
• 举例

public class Test {//ArrayList类的forEach方法遍历列表
    public static void main(String[] args) {
        ArrayList list = new ArrayList();//创建一个ArrayList对象
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);//给ArrayList对象中添加元素

        list.forEach(new Consumer() {//使用ArrayList自带的迭代器对列表元素遍历
            @Override
            public void accept(Object o) {//将Consumer类的匿名内部类作为参数
                System.out.println(o);//打印
            }
        });
    }
}

2. Vector

• Vector
  • 底层通过数组实现，查询快，增删慢
  • 线程安全，效率低
• 特有方法
  • public void addElement (E obj)
    • 在列表的末尾添加一个元素
  • public E elementAt (int index)
    • 获取指定索引位置处的元素

3. LinkedList

• LinkedList
  • 底层通过链表来实现，查询慢，增删快
  • 线程不安全，效率高
• 特有方法
  • public void addFirst(E e)及addLast(E e)
    • 在列表的首尾添加元素
  • public E getFirst()及getLast()
    • 得到列表的首尾元素
  • public E removeFirst()及public E removeLast()
    • 移除列表的首尾元素，并将首尾元素返回
• 举例：删除表中的重复元素

public class Test3 {//去除列表中的重复元素
    public static void main(String[] args) {
        LinkedList list = new LinkedList();//创建一个LinkedList对象

        list.addFirst(1);
        list.addFirst(4);
        list.addFirst(2);
        list.addFirst(4);
        list.addFirst(2);
        list.addFirst(3);
        list.addFirst(1);
        list.addFirst(4);
        list.addFirst(2);
        list.addFirst(4);
        list.addFirst(2);
        list.addFirst(4);
        list.addFirst(3);//添加元素
        
        System.out.println(list);//打印列表
        
        for (int i = 0; i < list.size(); i++) {//外层遍历每一个元素
            for (int j = i + 1; j < list.size(); j++) {//内层用外层元素与后面元素进行比较
                if ((int) list.get(i) == (int) list.get(j)) {//如果有相同元素，删除后面的元素
                    list.remove(j);
                    j--;//内层索引前移
                }
            }
        }
        System.out.println(list);//打印去重后的列表
    }
}

4. 三个子类使用时选择

• 如果增删场景比较多，考虑LinkedList类
• 如果线程安全要求较高，考虑Vector类
• 如果查询场景比较多，且效率要求较高，考虑ArrayList类

5. 集合嵌套

• 集合嵌套
  • 一个集合中的元素是另一个集合，叫做集合嵌套，类似于二维数组
  • 举例
    • 学校有多个班，一个班有多个学生。每个班学生的信息都是一个集合，而这些集合都是学校所有班这个大集合的元素