Java基础二十四（集合框架）

集合框架

Java 集合框架提供了一套性能优良、使用方便的接口和类，他们都位于 java.util 包中。Java 集合框架由3大类接口构成（Map接口、List接口、Set接口）.

1. letrable 接口

java.lang.lterable 接口是 Java 标准库中的一个接口，用于表示可迭代的集合类。实现了 lterable 接口的类可以使用 Java 中的 for-each 循环来遍历其元素，使其具有可迭代的特性。

返回值类型	方法名	描述
Iterator	iterator()	返回一个迭代器，用于遍历集合中的元素。
void	forEach(Consumer action)	对集合中的每个元素执行给定操作。
Spliterator	spliterator()	返回一个拆分器，用于对集合中的元素进行分割迭代。

例子

import java.util.*;

public class VectorExample {
    public static void main(String[] args) {
        Vector<Student> students = new Vector<Student>();

        students.add(new Student("犯困桃子", 10, 11));
        students.add(new Student("小羊呆呆", 20, 11));
        students.add(new Student("中科盛康人才", 5, 11));
        students.add(new Student("小羊", 30, 11));
        students.add(new Student("盛康人才", 1, 11));

        // 比较排序
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                return Integer.compare(s1.getMath(), s2.getMath());
            }
        });
		// 使用 for-each迭代输出
        for (Student student : students) {
            System.out.println(student);
        }

        students.get(3).setName("三娃");  // 设置名称
        students.insertElementAt(new Student("五娃", 20, 17), 4);  // 指定下标插入
        System.out.println(students.size());
        students.remove(students.size() - 1);  // 删除最后一个元素
		// 使用 iterator() 输出
        Iterator<Student> iterator = students.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

2. Collection 接口

Collection 接口是 Java.util 包下的一个接口，用于表示一组对象是集合。它是 Java 集合框架中的根接口，继承了 lterable 接口，因此它可以用于遍历集合中的元素。Collection 接口提供了一组通用的方法，用于对集合进行基本的操作。

方法名	返回值	描述
add(E e)	boolean	添加元素
addAll(Collection c)	boolean	将集合c中的所有元素添加到此集合中
clear()	void	清除所有元素
contains(Object o)	boolean	集合中是否包含指定元素
containsAll(Collection c)	boolean	集合是否包含指定集合中的所有元素
isEmpty()	boolean	集合是否为空
iterator()	Iterator	返回集合的迭代器
remove(Object o)	boolean	删除集合中的某个元素
removeAll(Collection c)	boolean	删除集合中与指定集合中相同的所有元素
retainAll(Collection c)	boolean	保留集合中与指定集合中相同的元素
size()	int	返回集合中的元素数
toArray()	Object[]	返回包含集合中所有元素的数组

Collection 接口实现的类包括常见的 ArrayList、LinkedList、HashSet、TreeSet、LinkedHashSet 等。

2.1 队列（Queue）

public interface Queue<E>
extends Collection<E>

设计用于在处理之前保留元素的集合。 除了基本的 Collection 操作之外，队列还提供额外的插入，提取和检查操作，不可以存 null。
下面是常用的Queue接口方法及其描述：

方法名	返回值类型	描述
add(E e)	boolean	将指定元素插入此队列 。如果队列已满，则会抛出IllegalStateException异常
offer(E e)	boolean	将指定元素插入此队列 。 如果队列已满，则会返回false
remove()	E	检索并删除此队列的头部 。如果队列为空，则会抛出NoSuchElementException异常
poll()	E	检索并删除此队列的头部，如果此队列为空，则返回null
element()	E	检索但不删除此队列的头部 。如果队列为空，则会抛出NoSuchElementException异常
peek()	E	检索但不删除此队列的头部，如果此队列为空，则返回null
size()	int	返回队列中的元素数
contains(Object o)	boolean	如果此队列包含指定元素，则返回true
clear()	void	移除此队列中的所有元素
toArray()	Object[]	返回包含此队列所有元素的数组；返回数组按照队列元素排列顺序

上述方法是 Queue 接口中常用的方法，通过实现该接口，并重写其中的方法，即可定义自己的队列实现类。Queue 接口实现的类有很多，例如常用的有 LinkedList、ArrayDeque 等。

Queue 接口不允许插入 null 元素，也不允许包含重复的元素。

2.2 Deque（双端队列）

public interface Deque<E>
extends Queue<E>

继承了 Queue ,支持两端(首尾)元素插入和移除的线性集合。

方法名	返回值类型	描述
addFirst(E e)	void	在双端队列的前面插入元素
addLast(E e)	void	在双端队列的末尾插入元素，类似于add(E e)
getFirst()	E	检索但不删除双端队列的第一个元素
getLast()	E	检索但不删除双端队列的最后一个元素
pop()	E	删除并返回双端队列的第一个元素
push(E e)	void	相当于addFirst(E e)，在双端队列的前面插入元素
removeFirstOccurrence(Object o)	boolean	从双端队列中删除第一次出现的指定元素，如果不存在则保持不变
removeLastOccurrence(Object o)	boolean	从双端队列中删除最后一次出现的指定元素，如果不存在则保持不变

2.3 set（集合）

public interface Set<E>
extends Collection<E>

集合中的对象并不能保存重复的对象，也就是说 Set 接口可以储存一组唯一、无序的对象。
在Java中，Set是一种集合接口，它继承自Collection接口。Set集合的主要属性如下：

1. 无序性：Set集合中的元素是无序排列的，不会按照插入顺序或者其他特定顺序进行存储。这是因为Set集合通常基于哈希表或红黑树实现，以提供快速的插入、删除和搜索操作。

2. 唯一性：Set集合中不允许包含重复的元素。当添加重复元素时，Set集合会自动拒绝并保留唯一性。

3. 不允许使用索引：Set集合没有提供索引访问元素的方法，因为它的元素是无序的。如果需要按索引访问元素，应该使用List集合。

4. 添加、删除和包含操作的性能较高：由于Set集合通常使用哈希表或红黑树实现，可以在常数时间内执行添加、删除和包含操作。

5. 允许使用null元素：Set集合允许存储一个null元素。但需要注意，HashSet和LinkedHashSet不保证存储顺序，而TreeSet不允许存储null元素。

常见的Set集合实现类有：

• HashSet：基于哈希表实现，具有较好的查找性能，不保证元素的存储顺序。
• LinkedHashSet：基于哈希表和链表实现，按插入顺序保留元素，具有较好的遍历性能。
• TreeSet：基于红黑树实现，按照元素的自然顺序或者指定的Comparator进行排序。

of 方法和 copyOf ，都是 static 方法返回一个不可修改的 Set 集合。

2.4 list接口（列表）

有序集合（也称为序列 ）。 该集合用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。

List 通常允许重复的元素、允许 null 元素

方法名	返回值类型	描述
add(int index, E element)	void	将指定的元素插入此列表中的指定位置
addAll(int index, Collection c)	boolean	将指定集合中的所有元素插入到此列表中的指定位置
get(int index)	E	返回此列表中指定位置的元素
indexOf(Object o)	int	返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回 -1
lastIndexOf(Object o)	int	返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回 -1
remove(int index)	E	删除该列表中指定位置的元素，返回被删除的元素
set(int index, E element)	E	用指定的元素（可选操作）替换此列表中指定位置的元素，返回被替换的值
subList(int fromIndex, int toIndex)	List	返回此列表中指定的 fromIndex （含）和 toIndex之间的元素集合
default sort(Comparator c)	void	按照 c 比较器进行自然排序 (JDK 8)
static copyOf(Collection coll)	List	按照迭代顺序返回一个不可修改的 List (JDK 10)
static of()	List	返回包含任意数量元素的不可修改列表 (JDK 9)

示例

import java.util.List;
import java.util.Scanner;

public class ListExample01 {
    public static void main(String[] args) {
		// List不可修改
        List commodity = List.of("棉花糖", "气球", "风筝", "饼干", "巧克力");
        Scanner input = new Scanner(System.in);
        System.out.println("请输入你要查询的商品信息");
        String str = input.next();

        if (commodity.contains(str)) {
            String information = (String) commodity.get(commodity.indexOf(str));
            System.out.println(information);
        } else {
            System.out.println("暂时没有这个商品");
        }
    }
}

主要子类： ArrayList 、 LinkedList 、 Vector、Stack 等。

2.4.1 Vector 类动态储存数据

Vector 类是一种动态数组，它可以自动扩展和缩小数组的大小，实现了 List 接口，且所有的方法都是同步的（线程安全的），适用于多线程环境中的操作。
Vector 类的特点：

1. 动态数组：Vector的大小可以根据需要自动增长或减小。当添加元素超过当前容量时，Vector会自动重新分配内部数组的大小以容纳更多的元素。默认大小为10，扩容为*2。
2. 线程安全：Vector是线程安全的，意味着多个线程可以同时对Vector进行读取和写入操作，而不会导致数据不一致的问题。Vector中的方法都使用了同步关键字来确保线程安全性。
3. 支持随机访问：Vector类支持通过索引值来访问集合在的元素，具有常数时间度的随机访问特性。
4. 可以包含重复元素
5. 可以插入 null

import java.util.Comparator;
import java.util.Iterator;
import java.util.Vector;

public class VectorExample02 {
    public static void main(String[] args) {
        Vector<Student> students = new Vector<Student>();

        students.add(new Student("犯困桃子", 10, 91));
        students.add(new Student("小羊呆呆", 20, 72));
        students.add(new Student("中科盛康人才", 5, 35));
        students.add(new Student("小羊", 30, 50));
        students.add(new Student("盛康人才", 1, 11));
        students.add(new Student("张三", 23, 90));
        students.add(new Student("李四", 24, 80));
        students.add(new Student("王五", 43, 70));
        students.add(new Student("赵六", 24, 80));
        students.add(new Student("田七", 25, 50));

        students.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return (sum(o1) - sum(o2)) * -1 ;
            }
        });

//        Iterator iterator = students.iterator();
//        while (iterator.hasNext()) {
//            Student student = iterator.next();
//            System.out.println(student + "\t" + avg(student));
//        }


        for (Student student : students) {
            System.out.println("" + student + "\t 平均成绩:" + avg(student));
        }
    }

    // 计算总成绩
    public static int sum(Student student) {
        return student.getTotal();
    }

    // 计算平均分
    public static double avg(Student student) {
        return (student.getTotal() / 2.0);
    }
}

2.4.2 Stack 类动态存储数据

Stack 类代表后进先出（LIFO） 堆栈的对象， Stack 继承自 Vector 所以它有所有 Vector 中的方法。

 public class Stack<E> extends Vector<E>

Stack 常用方法：

方法名	返回值类型	描述
empty()	boolean	判断此堆栈是否为空
peek()	E	返回此堆栈顶部的对象，而不从堆栈中删除它
pop()	E	返回并删除此堆栈顶部的对象
push(E item)	E	将指定对象添加到堆栈的顶部
search(Object o)	int	返回对象在此堆栈上的从1开始的位置，如果对象不在堆栈中，则返回 -1

示例

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        // 向Stack添加元素
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        // Stack 弹出元素
        System.out.println(stack.pop());  // 4
        // Stack 查看但不弹出
        System.out.println(stack.peek());  // 3
        // 判断是否为空
        System.out.println(stack.isEmpty());  // false
        // 查找元素所在位置
        System.out.println(3);  // 3
        System.out.println(stack);  // [1, 2, 3]
    }
}