集合排序 Collections.sort用法

最新推荐文章于 2025-11-19 18:49:44 发布

原创最新推荐文章于 2025-11-19 18:49:44 发布 · 8k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#java #jdk

JAVA入门专栏收录该内容

5 篇文章

订阅专栏

本文介绍了Java中Collections.sort方法的使用，包括如何通过Comparator接口进行自定义排序，以及使用匿名内部类和Lambda表达式简化代码。同时，讲解了sort方法的两种用法，一种接受List和Comparator，另一种则要求List的元素实现Comparable接口。文章还提供了相关示例代码，适合Java初学者参考。

大半夜,一同学来问这段代码.问了三个问题.

一,这个排序Sort()怎么用?

二,接口作为方法的参数是什么意思?

三,入参直接new Comparator(){}是怎么回事?

先回答第二,三个问题:

二,接口入参,意思就是:你需要传入一个实现了该接口的对象.

三,入参直接new Comparator(){};这是个匿名内部类(不知道的去问度娘),这个有什么用?没啥用!这跟你去新建个类,实现Comparator接口的compare方法,然后再new 对象放到参数里的效果是一样的.匿名内部类的用途就是可以偷懒(简洁),少敲代码.不需要再去单独建个类,再new对象.而是直接new接口.直接实现了.代码如下:

Collections.sort(list, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                //o1-o2降序(顺序),反之o2-o1则升序(反序).
                int ageC = o1.getAge() - o2.getAge();
                if (ageC == 0) {
                    return o1.getName().compareTo(o2.getName());
                } else {
                    return ageC;
                } }
        });

如果你使用1.8以上的jdk,匿名内部类还可以这样写.用lambda表达式.这写法有什么用?更简洁了,就是又少写了一些代码.代码如下:

//去掉User也可以 Collections.sort(list, (o1, o2) ->{

Collections.sort(list, (User o1, User o2) -> {            //o1-o2降序(顺序),反之o2-o1则升序(反序).
            int ageC = o1.getAge() - o2.getAge();
            if (ageC == 0) {
                return o1.getName().compareTo(o2.getName());
            } else {
                return ageC;
            }
        });

最后说下Collections.sort()两种用法.这是JDK java.util包自带的排序方法.这两个方法都是调用Arrays.sort(), 最终排序算法是legacyMergeSort()_归并排序或 TimSort.sort()_结合了合并排序（merge sort）和插入排序（insertion sort）而得出的排序算法

  //第一种方法   public static <T> void sort(List<T> list, Comparator<? super T> c) {        list.sort(c);    }  //第二种方法    public static <T extends Comparable<? super T>> void sort(List<T> list) {        list.sort(null);    }

第一种,入参是一个list,及Comparator () ,这个一个接口,接口可以用普通类实现后new对象入参,也可以用匿名内部类入参.

第二种,入参只有一个list,不过对list的泛型T做了限制,T或T的父类必须实现Comparable接口的compareTo方法.这个方法跟compare方法排序效果是一样的. 下面上demo.

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

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

        List<User> list = new ArrayList();
        list.add(new User(10, "test1"));
        list.add(new User(11, "test2"));
        list.add(new User(8, "test3"));
        //第一种用法1
        Collections.sort(list, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                //o1-o2降序(顺序),反之o2-o1则升序(反序).
                int ageC = o1.getAge() - o2.getAge();
                if (ageC == 0) {
                    //String类重写了compareTo方法
                    return o1.getName().compareTo(o2.getName());
                } else {
                    return ageC;
                }
            }
        });
        System.out.println(list.toString());

        //第一种用法2
        //jdk1.8lambda表达式写法
        Collections.sort(list, (User o1, User o2) -> {
            //o1-o2降序(顺序),反之o2-o1则升序(反序).
            int ageC = o1.getAge() - o2.getAge();
            if (ageC == 0) {
                return o1.getName().compareTo(o2.getName());
            } else {
                return ageC;
            }
        });
        
        List<UserC> list2 = new ArrayList();
        list2.add(new UserC(10, "test1"));
        list2.add(new UserC(11, "test2"));
        list2.add(new UserC(9, "test3"));
        //第二种用法
        Collections.sort(list2);
        System.out.println(list2.toString());
    }

//静态内部类,方便写demo,不然还得多建几个类
    static class User {

        int age;
        String name;

        public User(int age, String name) {
            this.age = age;
            this.name = name;
        }

        @Override
        public String toString() {
            return "User{" + "age=" + age + ", name='" + name + '\'' + '}';
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

    //静态内部类,方便写demo,不然还得多建几个类,实现了Comparable接口,泛型匹配UserC
    static class UserC implements Comparable<UserC> {

        int age;
        String name;

        public UserC() {
        }

        public UserC(int age, String name) {
            this.age = age;
            this.name = name;
        }

        @Override
        public String toString() {
            return "User{" + "age=" + age + ", name='" + name + '\'' + '}';
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public int compareTo(UserC o) {
            //o1-o2降序(顺序),反之o2-o1则升序(反序).
            int age = this.age - o.getAge();
            if (age == 0) {
                //String类重写了compareTo方法
                return this.name.compareTo(o.getName());
            }
            return age;
        }
    }
}

#欢迎关注-- ☆帮助各位同学辅导java相关问题☆.