Java-集合工具类(Collections)

前言

Collections是一个操作数组Set、List和Map等集合的工具类

Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、集合对象实现同步控制等方法
下面方法均为静态方法，使用Collections.xxxx()调用

1、排序操作

(1)、反转元素[reverse]

reverse(List list)：反转List中元素的顺序，改变的是数据本身

package com.tcc.test;

import java.util.*;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add(123);
        list.add(333);
        list.add(true);

        Collections.reverse(list);

        System.out.println(list); // [true, 333, 123]
    }
}

(2)、元素随机排序[shuffle]

shuffle(List list)：对List集合元素进行随机排序，改变的是数据本身

package com.tcc.test;

import java.util.*;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add(123);
        list.add(333);
        list.add(true);

        Collections.shuffle(list);

        System.out.println(list); // 第一次：[123, true, 333]   第二次：[true, 333, 123]
    }
}

(3)、根据元素自然顺序排序[sort]

sort(List list)：根据元素自然顺序对指定List集合元素排序，List集合里面数据类型必须一致

普通类型

---

package com.tcc.test;

import java.util.*;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(123);
        list.add(333);
        list.add(222);
        list.add(444);

        Collections.sort(list);

        System.out.println(list); // [123, 222, 333, 444]
    }
}

自定义类

---

需要先在自定义类上实现Comparable接口，重写排序规则

规则(先根据年龄排序，如果一致，则根据姓名排序)

@Override
public int compareTo(Object o) {
    if(o instanceof User){
        User user = (User)o;

        // 按照年龄排序
        int i = age.compareTo(user.age);

        // 如果年龄相同，那么根据姓名排序
        if(i == 0){
            return name.compareTo(user.name);
        }else {
            return i;
        }
    }else {
        throw new RuntimeException("比较类型不匹配");
    }
}

测试

package com.tcc.test;

import com.tcc.entity.User;

import java.util.*;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(new User("sdf",20));
        list.add(new User("asb",24));
        list.add(new User("abd",24));

        Collections.sort(list);

        System.out.println(list); // [User{name='sdf', age=20}, User{name='abd', age=24}, User{name='asb', age=24}]
    }
}

(4)、根据元素定制排序[sort]

sort(List list,Comparator com)：根据元素定制排序对指定List集合元素按升序排序，List集合里面数据类型必须一致

package com.tcc.test;

import com.tcc.entity.User;

import java.util.*;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(new User("sdf",20));
        list.add(new User("asb",24));
        list.add(new User("abd",24));

        // lamdba表达式
        Comparator com = (o1, o2) -> {
            if(o1 instanceof User && o2 instanceof User){
                User u1 = (User)o1;
                User u2 = (User)o2;

                int i = Integer.compare(u1.getAge(), u2.getAge());
                if(i == 0){
                    return u1.getName().compareTo(u2.getName());
                }
                return i;
            }else {
                throw new RuntimeException("比较类型不匹配");
            }
        };

        Collections.sort(list,com);

        System.out.println(list); // [User{name='sdf', age=20}, User{name='abd', age=24}, User{name='asb', age=24}]
    }
}

(5)、交换元素[swap]

swap(List l, int i, int j)：将指定list集合中的i处元素和j处元素进行交换

package com.tcc.test;

import com.tcc.entity.User;

import java.util.*;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(new User("sdf",20));
        list.add(new User("asb",24));
        list.add(new User("abd",24));
        list.add(true);

        Collections.swap(list,0,3);

        System.out.println(list); // [true, User{name='asb', age=24}, User{name='abd', age=24}, User{name='sdf', age=20}]
    }
}

2、查找&替换

(1)、根据自然排序，返回最大的元素[max]

max(Collection c)：根据元素的自然排序，返回给定集合中的最大元素，就不演示了

(2)、根据定制排序，返回最大的元素[max]

max(Collection c, Comparator c)：根据元素的定制排序，返回给定集合中的最大元素，就不演示了

(3)、根据自然排序，返回最小的元素[min]

min(Collection c)：根据元素的自然排序，返回给定集合中的最小元素，就不演示了

(4)、根据定制排序，返回最小的元素[min]

min(Collection c, Comparator c)：根据元素的定制排序，返回给定集合中的最小元素，就不演示了

(5)、元素的出现次数[frequency]

int frequency(List l, Object o)：返回集合中指定元素的出现次数

package com.tcc.test;

import com.tcc.entity.User;

import java.util.*;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(123);
        list.add(234);
        list.add(123);
        list.add(333);
        list.add(123);
        int i = Collections.frequency(list, 123);

        System.out.println(i); // 3
    }
}

(6)、拷贝(copy)

copy(LIst dest, List src)：将src中的内容复制到dest中

这个方法有个坑，注意：dest集合的size值，要比src集合的size值大才行

否则会报异常：Source does not fit in dest

(7)、新值换旧值

boolean replaceAll(List list, Object oldVal, Object newVal)：使用新值替换List对象的所有旧值

package com.tcc.test;

import com.tcc.entity.User;

import java.util.*;

/**
 * @author 宇辰
 * @date 2022/8/31-8:53
 **/
public class Test{
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(123);
        list.add(234);
        list.add(123);
        list.add(333);
        list.add(123);

        boolean b = Collections.replaceAll(list, 123, "张三");

        System.out.println(b); // true
        System.out.println(list); // [张三, 234, 张三, 333, 张三]
    }
}

3、封装为线程安全的

前面讲到集合，Collection中有一个古老的类Vector和Map中的古老的类HashTable都是我们现在开发中基本不适用的类了，原因就是每个方法都添加了synchronized是线程安全的，但是带来的就是效率降低，而其他好用的集合，虽然效率高，但都不是线程安全的。

想要使用其他集合，效率高，又想线程安全的，可以使用Collections工具类封装好的方法，如下

在方法里面可以看到，这些方法就是重新new了一个内部类，然后在方法前面都添加了synchronized关键字，然后返回给我们封装好的集合。