Young Kbt blog
Young Kbt
2021-10-23
目录

Java 集合 - Collections 工具类

# 前言

Java 提供了一个操作 Set、List 和 Map 等集合的工具类：Collections，该工具类提供了大量方法对集合进行排序、查询和修改等操作，还提供了将集合对象置为不可变、对集合对象实现同步控制等方法。

这个类不需要创建对象，内部提供的都是静态方法。

# Collectios概述

image-20220618215153648

此类完全由在 Collection 上进行操作或返回 Collection 的静态方法组成。它包含在 Collection 上操作的多态算法，即「包装器」，包装器返回由指定 Collection 支持的新 Collection，以及少数其他内容。如果为 此类的方法所提供的 Collection 或类对象为 null，则这些方法都将抛出 NullPointerException。

# 排序操作

static void reverse(List<?> list)// 反转列表中元素的顺序。

static void shuffle(List<?> list) // 对 List 集合元素进行随机排序。

static void sort(List<T> list) // 根据元素的自然顺序 对指定列表按升序进行排序

static <T> void sort(List<T> list, Comparator<? super T> c) // 根据指定比较器产生的顺序对指定列表进行排序。
    
static void swap(List<?> list, int i, int j)   // 在指定 List 的指定位置 i,j 处交换元素。

static void rotate(List<?> list, int distance)
 //当 distance 为正数时，将 List 集合的后 distance 个元素「整体」移到前面；当 distance 为负数时，将 List 集合的前 distance 个元素「整体」移到后边。该方法不会改变集合的长度
1
2
3
4
5
6
7
8
9
10
11
12

演示

public static void main(String[] args) {
    ArrayList list = new ArrayList();
    list.add(3);
    list.add(-2);
    list.add(9);
    list.add(5);
    list.add(-1);
    list.add(6);

    // 输出：[3, -2, 9, 5, -1, 6]
    System.out.println(list);
    // 集合元素的次序反转
    Collections.reverse(list);
    // 输出：[6, -1, 5, 9, -2, 3]
    System.out.println(list);
    // 排序：按照升序排序
    Collections.sort(list);
    // [-2, -1, 3, 5, 6, 9]
    System.out.println(list);
    // 根据下标进行交换
    Collections.swap(list, 2, 5);
    // 输出：[-2, -1, 9, 5, 6, 3]
    System.out.println(list);
    
    /* // 随机排序
    Collections.shuffle(list);
    // 每次输出的次序不固定
    System.out.println(list);*/
    
    // 后两个整体移动到前边
    Collections.rotate(list, 2);
    // 输出：[6, 9, -2, -1, 3, 5]
    System.out.println(list);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

创建学生集合，加入数据，并 自定义排序，先根据年龄，再根据首字母

pojo 类

public class Student {
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
1
2
3
4
5
6
7
8
9

Test 类

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> array = new ArrayList<>();
        Student s1 = new Student("lingqingxia",20);
        Student s2 = new Student("wangxizhi",30);
        Student s3 = new Student("libai",25);
        Student s4 = new Student("dufu",25);
        // Student s5 = new Student("dufu",25);

        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        // array.add(s5);
        Collections.sort(array, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int i = o1.age-o2.age;
                int n = i==0?o1.name.compareTo(o2.name):i;
                return n;
            }
        });

        for (Student s:array){
            System.out.println(s.name+","+s.age);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 查找、替换操作

方法

// 使用二分搜索法搜索指定列表，以获得指定对象在 List 集合中的索引。
// 注意：此前必须保证 List 集合中的元素已经处于有序状态。
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)

// 根据元素的自然顺序，返回给定 Collection 的最大元素。
static Object max(Collection coll)

   	// 根据指定比较器产生的顺序，返回给定 Collection 的最大元素。
    static Object max(Collection coll,Comparator comp)

    // 根据元素的自然顺序，返回给定 Collection 的最小元素。
    static Object min(Collection coll)
    
    // 根据指定比较器产生的顺序，返回给定 Collection 的最小元素。
    static Object min(Collection coll,Comparator comp)
    
    使用指定元素替换指定列表中的所有元素。
    static <T> void fill(List<? super T> list, T obj)
    
    // 返回指定 Collection 中等于指定对象的出现次数。
    static int frequency(Collection<?> c, Object o)
    
    // 返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
    static int indexOfSubList(List<?> source, List<?> target) 
    
    // 返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
    static int lastIndexOfSubList(List<?> source, List<?> target)
    
    // 使用一个新值替换 List 对象的所有旧值 oldVal
    static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

演示：实例使用查找、替换操作

public static void main(String[] args) {
    ArrayList list = new ArrayList();
    list.add(3);
    list.add(-2);
    list.add(9);
    list.add(5);
    list.add(-1);
    list.add(6);
    // [3, -2, 9, 5, -1, 6]
    System.out.println(list);
    // 输出最大元素 9
    System.out.println(Collections.max(list));
    // 输出最小元素：-2
    System.out.println(Collections.min(list));
    // 将 list 中的 -2 用 1 来代替
    System.out.println(Collections.replaceAll(list, -2, 1));
    // [3, 1, 9, 5, -1, 6]
    System.out.println(list);
    list.add(9);
    // 判断 9 在集合中出现的次数，返回 2
    System.out.println(Collections.frequency(list, 9));
    // 对集合进行排序
    Collections.sort(list);
    // [-1, 1, 3, 5, 6, 9, 9]
    System.out.println(list);
    // 只有排序后的 List 集合才可用二分法查询，输出 2
    System.out.println(Collections.binarySearch(list, 3));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 同步控制

Collectons 提供了多个 synchronizedXxx() 方法，该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。

正如前面介绍的 HashSet，TreeSet，ArrayList，LinkedList，HashMap，TreeMap 都是线程不安全的。Collections 提供了多个静态方法可以把他们包装成线程同步的集合。

方法

// 返回指定 Collection 支持的同步（线程安全的）Collection。
static <T> Collection<T> synchronizedCollection(Collection<T> c)
    
// 返回指定列表支持的同步（线程安全的）列表。
static <T> List<T> synchronizedList(List<T> list)

// 返回由指定映射支持的同步（线程安全的）映射。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

// 返回指定 Set 支持的同步（线程安全的）Set
static <T> Set<T> synchronizedSet(Set<T> s)
1
2
3
4
5
6
7
8
9
10
11

实例

public static void main(String[] args) {
    // 下面程序创建了四个同步的集合对象
    Collection c = Collections.synchronizedCollection(new ArrayList());
    List list = Collections.synchronizedList(new ArrayList());
    Set s = Collections.synchronizedSet(new HashSet());
    Map m = Collections.synchronizedMap(new HashMap());

}
1
2
3
4
5
6
7
8

# Collesction设置不可变集合

方法

// 返回一个空的、不可变的集合对象，此处的 Xxx 集合既可以是 List，也可以是 Set，还可以是 Map。
emptyXxx()

// 返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，此处的 Xxx 集合可以是：List，Set，Map。
singletonXxx()
    
// 返回指定集合对象的不可变视图，此处的 Xxx 集合可以是：List，Set，Map。
unmodifiableXxx()
1
2
3
4
5
6
7
8

上面三类方法的参数是原有的集合对象，返回值是该集合的「只读」版本。

实例

public static void main(String[] args) {
    // 创建一个空的、不可改变的 List 对象
    List<String> unmodifiableList = Collections.emptyList();
    // 添加出现异常：java.lang.UnsupportedOperationException
    // unmodifiableList.add("java");
    System.out.println(unmodifiableList);// []
    // 创建一个只有一个元素，且不可改变的Set对象
    Set unmodifiableSet = Collections.singleton("Struts2权威指南");
    // [Struts2 权威指南]
    System.out.println(unmodifiableSet);
    // 创建一个普通 Map 对象
    Map scores = new HashMap();
    scores.put("语文", 80);
    scores.put("Java", 82);
    // 返回普通 Map 对象对应的不可变版本
    Map unmodifiableMap = Collections.unmodifiableMap(scores);
    // 下面任意一行代码都将引发 UnsupportedOperationException 异常
    unmodifiableList.add("测试元素");
    unmodifiableSet.add("测试元素");
    unmodifiableMap.put("语文", 90);
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 总结和测试

实体类：Pojo

import java.util.*;


public class CollectionsTest {
    public static void main(String[] args) {
        // 创建一个空的、不可改变的List对象
        List<String> unmodifiableList = Collections.emptyList();
        // 添加出现异常：java.lang.UnsupportedOperationException
        // unmodifiableList.add("java");
        System.out.println(unmodifiableList);// []
        // 创建一个只有一个元素，且不可改变的 Set 对象
        Set unmodifiableSet = Collections.singleton("Struts2权威指南");
        // [Struts2 权威指南]
        System.out.println(unmodifiableSet);
        // 创建一个普通 Map 对象
        Map scores = new HashMap();
        scores.put("语文", 80);
        scores.put("Java", 82);
        // 返回普通 Map 对象对应的不可变版本
        Map unmodifiableMap = Collections.unmodifiableMap(scores);
        // 下面任意一行代码都将引发 UnsupportedOperationException 异常
        unmodifiableList.add("测试元素");
        unmodifiableSet.add("测试元素");
        unmodifiableMap.put("语文", 90);

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

测试类代码如下

import java.util.ArrayList;
import java.util.List;

public class Test01 {
    public static void main(String[] args) throws Exception {
        // 一个对象对应了一行记录
        Employee e1 = new Employee(0301, "狂神", 3000, "项目部", "2017-10");
        Employee e2 = new Employee(0302, "小明", 3500, "教学部", "2016-10");
        Employee e3 = new Employee(0303, "小红", 3550, "教学部", "2016-10");
        List<Employee> list = new ArrayList<Employee>();
        list.add(e1);
        list.add(e2);
        list.add(e3);
        printEmpName(list);
    }

    public static void printEmpName(List<Employee> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).getName() + "-" + list.get(i).getHireDate());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 斗地主案例

简易版本

public static void main(String[] args) {
    ArrayList<String> array = new ArrayList<>();

    String[] colors = {"方片", "梅花", "黑桃", "红桃"};
    String[] numbers = {"1","2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};

    for (String c : colors) {
        for (String n : numbers) {
            array.add(c + n);
        }
    }
    array.add("小王");
    array.add("大王");
    Collections.shuffle(array); // 洗牌

    // 发牌
    ArrayList<String> wj1 = new ArrayList<>(); // 玩家 1
    ArrayList<String> wj2 = new ArrayList<>();
    ArrayList<String> wj3 = new ArrayList<>();
    ArrayList<String> dp = new ArrayList<>(); // 底牌


    for (int i = 0; i < array.size(); i++) {
        String s = array.get(i);
        if (i >= array.size() - 3) {
            dp.add(s);
        }else{
            int i1 = i % 3;
            switch (i1){
                case 0:
                    wj1.add(s);
                    break;
                case 1:
                    wj2.add(s);
                    break;
                case 2:
                    wj3.add(s);
                    break;
            }
        }
    }
    // 看牌
    System.out.println("底牌："+dp);
    System.out.println("玩家1的牌"+wj1);
    System.out.println("玩家2的牌"+wj2);
    System.out.println("玩家3的牌"+wj3);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

底牌：[梅花1, 黑桃2, 红桃Q]

玩家1的牌[黑桃10, 大王, 方片7, 梅花5, 方片9, 方片3, 黑桃4, 红桃8, 梅花4, 红桃9, 红桃2, 红桃4, 小王, 方片K, 红桃6, 黑桃6, 红桃K]

玩家2的牌[红桃1, 红桃7, 黑桃7, 方片J, 红桃J, 梅花3, 梅花7, 梅花8, 梅花9, 梅花2, 梅花J, 红桃10, 方片10, 黑桃5, 方片1, 黑桃K, 黑桃Q]

玩家3的牌[方片5, 方片4, 黑桃9, 方片8, 黑桃3, 方片Q, 方片6, 红桃5, 梅花6, 黑桃8, 黑桃1, 梅花Q, 红桃3, 梅花10, 方片2, 梅花K, 黑桃J]

可以看到，能实现洗牌，发牌，看牌，但是牌的顺序不是从小到大的，我们来改进一下

image-20220618215200486

  1. 用 HashMap 键值对从 0 到 53 序号，存储牌
  2. 用 ArrayList 存牌的序号
  3. 用 TreeSet 存玩家的牌的序号，TreeSet 可以自动排序
  4. 通过 TreeSet 的序号，从 HashMap 中查取牌
public class Poker {
    public static void main(String[] args) {
        // 编号，牌
        HashMap<Integer,String> hm = new HashMap<>();
        // 储存编号
        ArrayList<Integer> array = new ArrayList<>();

        String[] colors = {"方片", "梅花", "黑桃", "红桃"};
        String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K","A","2"};
        int index=0;
        for (String c:colors){
            for (String n:numbers){
                hm.put(index,c+n);
                array.add(index);
                index++;
            }
        }
        hm.put(index,"小王");
        array.add(index);
        index++;
        hm.put(index,"大王");
        array.add(index);

        Collections.shuffle(array); // 洗牌
        // 发牌
        TreeSet<Integer> wj1 = new TreeSet<>(); // 玩家1
        TreeSet<Integer> wj2 = new TreeSet<>();
        TreeSet<Integer> wj3 = new TreeSet<>();
        TreeSet<Integer> dp  = new TreeSet<>(); // 底牌

        for (int i = 0; i < array.size(); i++) {
            Integer s = array.get(i);
            if (i >= array.size() - 3) {
                dp.add(s);
            }else{
                int i1 = i % 3;
                switch (i1){
                    case 0:
                        wj1.add(s);
                        break;
                    case 1:
                        wj2.add(s);
                        break;
                    case 2:
                        wj3.add(s);
                        break;
                }
            }
        }
        lookpoke("玩家1",wj1 ,hm);
        lookpoke("玩家2",wj2 ,hm);
        lookpoke("玩家3",wj3 ,hm);
        lookpoke("底牌",dp ,hm);

    }
    public  static void lookpoke(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
        System.out.print(name+"的牌：   ");
        for (Integer t:ts){
            System.out.print(hm.get(t)+" ");
        }
        System.out.println();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
编辑此页 (opens new window)
更新时间: 2024/11/02, 18:07:00
Java 集合 - 泛型
JUC - 概念

← JUC - 概念→

最近更新
01
技术随笔 - Element Plus 修改包名 原创
11-02
02
Reactor - 扩展性
11-02
03
Reactor - 最佳实践
11-02
更多文章>
Theme by Vdoing | Copyright © 2021-2024 Young Kbt | blog
桂ICP备2021009994号