Java基础-集合的Collections工具类

Collections概述

Colllections是一个操作Set,List,Map等集合的工具类，提供了排序、查找、替换、同步控制、设置不可变集合（JAVA9开始）等方法

常用方法

排序

• void reverse(List<?> list)：反转指定列表中元素的顺序。
• void shuffle(List<?> list)：对指定列表中的元素进行随机排序
• void sort(List list)：对指定列表进行自然排序
• void sort(List list,Comparator c)：对指定列表进行自定义排序
• void swap(List list,int i,int j)：将指定列表中i位置的元素和j位置的元素调换
• void rotate(List list,int distance)：按指定距离旋转指定列表中的元素。

import java.util.*;

/**
 * 2021/12/23 21:55
 *  * @author 小豪的小目标
 * @version 1.0
 */
public class SortTest {
    public static void main(String[] args) {

        //定义一个List
        List<String> list = new ArrayList<>();
        list.add("第一个元素");
        list.add("第二个元素");
        list.add("第三个元素");
        System.out.println(list);//[第一个元素, 第二个元素, 第三个元素]

        Collections.reverse(list);//反转list列表中元素的顺序
        System.out.println(list);//[第三个元素, 第二个元素, 第一个元素]

        Collections.shuffle(list);//随机排序
        System.out.println(list);//[第三个元素, 第二个元素, 第一个元素]

        Collections.sort(list);//根据元素的自然顺序对指定 List 集合的元素按升序进行排序
        System.out.println((int)'一');//19968
        System.out.println((int)'二');//20108
        System.out.println((int)'三');//19977
        System.out.println(list);//[第一个元素, 第三个元素, 第二个元素]
        //通过上述程序可以看到他们根据从小到大排序

        Collections.sort(list, new Comparator<String>() {
            /*
            * compare中返回值为0或负数,则比较的两个数不调整顺序，如果为负数，则调整顺序
            * */
            @Override
            public int compare(String o1, String o2) {
                return o1.hashCode()-o2.hashCode();
            }
        });
        System.out.println(list); //输出[第一个元素, 第三个元素, 第二个元素]
        Collections.swap(list,2,1);//调换list中索引2元素和索引1元素的位置
        System.out.println(list); //[第一个元素, 第二个元素, 第三个元素]

        Collections.rotate(list,2);//按指定距离旋转指定列表中的元素
        System.out.println(list);
    }
}

查询、替换

• int binarySearch(List list,Object key):使用二进制搜索算法在指定列表中搜索指定对象。必须要保证list处于有序的状态
• Object max(Collection coll):返回集合中自然排序最大的值
• Object max(Collection coll,Comparator comp):返回指定Comparator排序规则中最小的值
• Object min(Collection coll):返回集合中自然排序最小的值
• Object min(Collection coll,Comparator comp):返回指定Comparator排序规则中最小的值
• void fill(List list,Object obj):使用obj替换list中的所有元素
• int frequency(Collection c,Object obj):返回obj在集合中出现的总次数
• int indexOfSubList(List source,List target):返回target在source中第一次出现的索引
• int lastIndexOfSubList(List source,List target):返回target在source中最后一次出现的索引
• boolean replaceAll(List list,Object oldVal,Object newVal):用newVal替换list中的所有oldVal元素

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

/**
 * 2021/12/24 10:57
 *
 * @author 小豪的小目标
 * @version 1.0
 */
public class Search {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a1");
        list.add("b2");
        list.add("c3");
        list.add("a1");
        list.add("d3");
        System.out.println(list);
        System.out.println(Collections.binarySearch(list,"a1")); //0

        System.out.println(Collections.max(list));//d3
        System.out.println(Collections.max(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.hashCode()-o2.hashCode();
            }
        })); //d3
        System.out.println(Collections.min(list));//a1
        System.out.println(Collections.min(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.hashCode()-o2.hashCode();
            }
        }));//

        ArrayList list2 = new ArrayList();
        list2.add("A1");
        list2.add("B2");
        Collections.fill(list2,"C3");
        System.out.println(list2);//[C3, C3]

        System.out.println(Collections.frequency(list,"a1"));//2

        ArrayList list3 = new ArrayList();
        list3.add("a1");
        System.out.println(Collections.indexOfSubList(list,list3));//0
        System.out.println(Collections.lastIndexOfSubList(list,list3));//3
        list3.add("a1");
        System.out.println(Collections.indexOfSubList(list,list3));//-1
        System.out.println(Collections.lastIndexOfSubList(list,list3));//-1

        Collections.replaceAll(list,"a1","A1");
        System.out.println(list);//[A1, b2, c3, A1, d3]
    }
}

同步控制

synchronizedCollection
synchronizedSet
synchronizedHash
synchronizedMap
其它的类似方法可以查看手册了解。
通过上述方法即可完成集合的线程安全实现。但是由于以上方法的效率较低。我们定义集合时一般使用

• ConcurrentHashMap
• ConcurrentLinkedDeque
• ConcurrentLinkedQueue
• ConcurrentMap
• ConcurrentNavigableMap
• ConcurrentSkipListMap
• ConcurrentSkipListSet

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 2021/12/24 15:29
 *
 * @author 小豪的小目标
 * @version 1.0
 */
public class SynchronizedTest {
    public static void main(String[] args) {
        Collection c1 = Collections.synchronizedCollection(new ArrayList());
        List c2 = Collections.synchronizedList(new ArrayList());
        Set c3 = Collections.synchronizedSet(new HashSet());
        Map c4 = Collections.synchronizedMap(new HashMap());
        ConcurrentHashMap chm = new ConcurrentHashMap();
    }
}

设置不可变集合

emptyXxx()：返回一个空的不可变集合
singletonXxx(值或键，值)：返回一个只包含一个值的集合
unmodifiableXxx(Collection)：返回指定对象不得不可变集合

/**
 * 2021/12/24 15:44
 *
 * @author 小豪的小目标
 * @version 1.0
 */
public class ImmutableTest {
    public static void main(String[] args) {
        Collection<Object> list = Collections.emptyList();
        //list.add("a");//运行报错UnsupportedOperationException
        Collection<Object> list2 = Collections.singletonList("集合");
        //list2.add("集合2");//运行报错UnsupportedOperationException
        System.out.println(list2);
        ArrayList list4 = new ArrayList();
        list4.add("4-元素1");
        list4.add("4-元素2");
        List list3 = Collections.unmodifiableList(list4);
        //list3.add("3-元素1");//运行报错UnsupportedOperationException
        System.out.println(list3);
    }
}