『Java』Collection接口 Collections类

接口Collection

public interface Collection<E>定义了所有单列集合中共性的方法，所有的单列集合都可以使用共性方法。

Collection的常用子接口有：

1. public interface List<E> extends Collection<E>：

   1. 特点：『有序』、『允许存储重复元素』、『有索引』（可以使用普通的for循环）
   2. 常用实现类有：
      • java.util.ArrayList
      • java.util.LinkedList

2. public interface Set<E> extends Collection<E>：

   1. 特点： 『 无序 』 、 『 不可存储重复元素 』 （不可使用普通for循环）

      更正式地说，集合中不包含e1和e2这样的一对元素，满足e1.equals(e2)

   2. 常用实现类：java.util.HashSet

Collection接口中定义的一些抽象方法：

1. int size()： 返回此集合中元素的数量
2. boolean isEmpty()： 如果该集合不包含元素，则返回true，否则返回false
3. boolean contains(Object o)： 如果该集合包含指定的元素，则返回true，否则返回false
4. Iterator<E> iterator()： 返回该集合中元素的迭代器， 不能保证元素返回的顺序
5. Object[] toArray()： 返回一个包含此集合中所有元素的数组
6. boolean add(E e)：往集合中添加元素，成功返回true，失败返回false
7. boolean remove(Object o)：从集合中删除指定元素，如果存在的话，返回true，
8. boolean containsAll(Collection<?> c)： 如果该集合包含指定集合中的所有元素，则返回true。
9. boolean addAll(Collection<? extends E> c)：将指定集合中的所有元素添加到此集合
10. boolean removeAll(Collection<?> c)： 删除指定集合中包含的该集合的所有元素
11. void clear()： 从集合中删除所有元素

类Collections

public class Collections extends Object该【类】专门由操作或返回集合的静态方法组成。

Collections中定义的静态常量

public static final List EMPTY_LIST = new EmptyList<>();
public static final Map EMPTY_MAP = new EmptyMap<>();
public static final Set EMPTY_SET = new EmptySet<>();

Collections中定义的静态方法

代码中的注释中被【】括起来的内容是对应的输出结果。

import java.util.ArrayList;
import java.util.Collections;

public class CLASS1 {
    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<>();

        // ===========addAll(Collection c, T... elements)===========
        Collections.addAll(arr, 3, 1, 5, 4, 2); // 往指定集合中添加元素，第二个参数是一个可变参数
        System.out.println(arr); // 【[3, 1, 5, 4, 2]】

        // ===========sort(List)===========
        Collections.sort(arr); // 默认升序排列
        System.out.println(arr); // 【[1, 2, 3, 4, 5]】

        // ===========sort(List, Comparator)=========
        Collections.sort(arr, ((o1, o2) -> o2 - o1)); // 通过实现Comparator接口实现降序排列
        System.out.println(arr); // 【[5, 4, 3, 2, 1]】

        // ===========binarySearch(List, key)===========
        int ind = Collections.binarySearch(arr, 2);
        System.out.println(ind); // arr目前是降序排列，而二分查找默认是按照升序排列进行的，所以找不到，返回【-1】

        // ===========binarySearch(List, key， Comparator)===========
        ind = Collections.binarySearch(arr, 2, (o1, o2) -> o2 - o1);
        System.out.println(ind); // 降序排列使用二分查找，返回索引值【3】，索引从0开始

        // ===========reverse(List)===========
        Collections.reverse(arr); // 反转List
        System.out.println(arr); // 【[1, 2, 3, 4, 5]】

        // ===========max(List) & min(List)===========
        System.out.println(Collections.max(arr)); // 【5】
        System.out.println(Collections.min(arr)); // 【1】

        // ===========shuffle(List)===========
        Collections.shuffle(arr); // 打乱集合中的元素排列顺序
        System.out.println((arr)); // 【[2, 4, 3, 1, 5]】
    }
}