Java基础-集合的Collections工具类

文章目录

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.*;


public class SortTest {
    public static void main(String[] args) {

        //定义一个List
        List 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() {
            
            @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;


public class Search {
    public static void main(String[] args) {
        ArrayList 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() {
            @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() {
            @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;


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)：返回指定对象不得不可变集合

public class ImmutableTest {
    public static void main(String[] args) {
        Collection

Java基础-集合的Collections工具类

Java相关栏目本月热门文章