Collections集合和Comparator比较器

java.utils.Collections是集合工具类,用来对集合进行操作。

Collections 工具类常用方法:
排序
查找,替换操作
同步控制(不推荐,需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合)

void reverse(List list)//反转
void shuffle(List list)//随机排序
void sort(List list)//按自然排序的升序排序
void sort(List list, Comparator c)//定制排序,由Comparator控制排序逻辑
void swap(List list, int i , int j)//交换两个索引位置的元素
void rotate(List list, int distance)//旋转。当distance为正数时,将list后distance个元素整体移到前面。当distance为负数时,将 list的前distance个元素整体移到后面。
import java.util.*;

public  class test{
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(-1);
        arrayList.add(3);
        arrayList.add(3);
        arrayList.add(-5);
        arrayList.add(7);
        arrayList.add(4);
        arrayList.add(-9);
        arrayList.add(-7);
        System.out.println("原始数组:");
        System.out.println(arrayList);
        // void reverse(List list):反转
        Collections.reverse(arrayList);
        System.out.println("Collections.reverse(arrayList):");
        System.out.println(arrayList);


        Collections.rotate(arrayList, 4);
        System.out.println("Collections.rotate(arrayList, 4):");
        System.out.println(arrayList);

        // void sort(List list),按自然排序的升序排序
        Collections.sort(arrayList);
        System.out.println("Collections.sort(arrayList):");
        System.out.println(arrayList);

        // void shuffle(List list),随机排序
        Collections.shuffle(arrayList);
        System.out.println("Collections.shuffle(arrayList):");
        System.out.println(arrayList);

        // void swap(List list, int i , int j),交换两个索引位置的元素
        Collections.swap(arrayList, 2, 5);
        System.out.println("Collections.swap(arrayList, 2, 5):");
        System.out.println(arrayList);

        // 定制排序的用法
        Collections.sort(arrayList, new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println("定制排序后:");
        System.out.println(arrayList);
    }
}

在这里插入图片描述

int binarySearch(List list, Object key)//对List进行二分查找,返回索引,注意List必须是有序的
int max(Collection coll)//根据元素的自然顺序,返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)//根据定制排序,返回最大元素,排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。
int frequency(Collection c, Object o)//统计元素出现次数
int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引,找不到则返回-1,类比int lastIndexOfSubList(List source, list target).
boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素
import java.util.*;

public  class test{
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(-1);
        arrayList.add(3);
        arrayList.add(3);
        arrayList.add(-5);
        arrayList.add(7);
        arrayList.add(4);
        arrayList.add(-9);
        arrayList.add(-7);
        ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
        arrayList2.add(-3);
        arrayList2.add(-5);
        arrayList2.add(7);
        System.out.println("原始数组:");
        System.out.println(arrayList);

        System.out.println("Collections.max(arrayList):");
        System.out.println(Collections.max(arrayList));

        System.out.println("Collections.min(arrayList):");
        System.out.println(Collections.min(arrayList));

        System.out.println("Collections.replaceAll(arrayList, 3, -3):");
        Collections.replaceAll(arrayList, 3, -3);
        System.out.println(arrayList);

        System.out.println("Collections.frequency(arrayList, -3):");
        System.out.println(Collections.frequency(arrayList, -3));

        System.out.println("Collections.indexOfSubList(arrayList, arrayList2):");
        System.out.println(Collections.indexOfSubList(arrayList, arrayList2));

        System.out.println("Collections.binarySearch(arrayList, 7):");
        // 对List进行二分查找,返回索引,List必须是有序的
        Collections.sort(arrayList);
        System.out.println(Collections.binarySearch(arrayList, 7));
    }
}

在这里插入图片描述

例2

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

public class test {
    public static void main(String[] args) {
        ArrayList<String> list =new ArrayList<>();
        //`public static <T> boolean addAll(Collection<T> c, T... elements)  `:往集合中添加一些元素。
        Collections.addAll(list,"a","b","c","d","e");
        System.out.println(list);
        //`public static void shuffle(List<?> list) 打乱顺序`:打乱集合顺序。
        Collections.shuffle(list);
        System.out.println(list);
        //`public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序。
        Collections.sort(list);
        System.out.println(list);

        //`public static <T> void sort(List<T> list,Comparator<? super T> )`:将集合中元素按照指定规则排序。
        ArrayList<String> lis = new ArrayList<String>();
        lis.add("cba");
        lis.add("aba");
        lis.add("sba");
        lis.add("nba");
        System.out.println(lis);
        /*
        * ` public int compare(String o1, String o2)`:比较其两个参数的顺序。
        * 两个对象比较的结果有三种:大于,等于,小于。
        * 如果要按照升序排序,则o1 小于o2,返回(负数),相等返回0,01大于02返回(正数)
        * 如果要按照降序排序,则o1 小于o2,返回(正数),相等返回0,01大于02返回(负数)
        * */
        Collections.sort(lis, new Comparator<String>() {
            @Override
            public int compare(String s, String t1) {
                //return 0;
                return s.charAt(0)-t1.charAt(0);
            }
        });
        System.out.println(lis);
    }
}
Comparator比较器是Java中的一个接口,它定义了一个用于比较两个对象的方法compare(Object obj1, Object obj2)。通过实现Comparator接口,我们可以自定义比较器来比较两个对象之间的大小关系。 在Java中,如果我们想对一个集合进行排序,可以使用Collections.sort()方法来实现。sort()方法接收一个List类型的参数,并可以选择性地传入一个Comparator类型的参数,用于指定排序规则。 Comparator接口中的compare方法返回一个int类型的值,表示两个对象之间的大小关系。如果第一个对象小于第二个对象,则返回负数;如果第一个对象等于第二个对象,则返回0;如果第一个对象大于第二个对象,则返回正数。 以下是一个使用Comparator比较器对整数数组进行排序的例子: ``` Integer[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}; Arrays.sort(arr, new Comparator<Integer>() { public int compare(Integer o1, Integer o2) { return o1 - o2; } }); ``` 在这个例子中,我们使用Arrays.sort()方法对整数数组进行排序。我们通过实现Comparator接口,定义了一个比较器,将整数按升序排序。 除了使用匿名内部类来实现Comparator接口外,我们还可以使用Lambda表达式或者方法引用来实现Comparator接口。 总之,Comparator比较器是Java中非常常用的一个接口,它可以让我们自定义比较器,定义排序规则。熟练掌握Comparator比较器的使用方法可以让我们更好地处理集合数据。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值