list集合自定义排序

一、基本类型排序

1.list中只有数字或字符串

//升序排序 List<T> ,T为数字或字符串 
Collections.sort(list);
//降序排序
Collections.sort(list,Collections.reverseOrder());
 

2.list中为对象

基于jdk.18

import lombok.Data;
 
@Data
public class User {
 
    private int id;
    private int age;
    private String name;
    
    public User(int id, int age, String name) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
 
}

2.1 使用Comparator排序 

Comparator 是类外部的比较器。使用此可构造一个可拓展的工具，无需修改原类。实现方法有两种：

2.1.1新建Compartor比较器

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class SortTest {
 
    public static void main(String[] args) {
        // 初始化数据
        List list = new ArrayList() {{
            add(new User(1, 43, "北京"));
            add(new User(2, 16, "天津"));
            add(new User(3, 33, "石家庄"));
            add(new User(4, 27, "深圳"));
        }};
 
        // 使用 Comparator 比较器排序
        Collections.sort(list, new UserComparator());
        // 打印 list 集合
        list.forEach(p -> {System.out.println(p);});
 
    }
}
/**
 * 构建User比较器
 */
class UserComparator implements Comparator {
    @Override
    //正数排前
    public int compare(User p1, User p2) {
        return p1.getAge() - p2.getAge();
    }
}

结果如下图所示：

 2.1.2匿名类比较器

 比较器Comparator可以使用匿名类的方式，更加简洁的实现排序，代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class SortTest {
 
    public static void main(String[] args) {
        // 初始化数据
        List list = new ArrayList() {{
            add(new User(1, 43, "北京"));
            add(new User(2, 16, "天津"));
            add(new User(3, 33, "石家庄"));
            add(new User(4, 27, "深圳"));
        }};
 
        // 使用 Comparator 的匿名内部类 比较器排序
        Collections.sort(list, new Comparator(){
            @Override
            //倒数排前
            public int compare(User p1, User p2) {
                return p2.getAge() - p1.getAge();
            }
        });
        // 打印 list 集合
        list.forEach(p -> {System.out.println(p);});
 
    }
}

结果如下图所示 

 2.1.3 静态内部类

        //按照List中对象的id属性升序,默认升序
        list.sort(Comparator.comparing(User::getId));
 
        //按照List中对象的id属性降序
        list.sort(Comparator.comparing(User::getId).reversed());
 
        //多条件升序
        list.sort(Comparator.comparing(User::getId).thenComparing(User::getAge));
 
        //首先按id对对象进行排序，如果id相同，则按age进行排序
        list.sort(Comparator.comparing(User::getId).reversed().thenComparing(User::getAge).reversed());

2.2 使用Comparable排序

Comparable 是类内部的比较方法，需要修改比较类的内部方法，实现如下:

import lombok.Data;
 
@Data
public class User implements Comparable{
 
    private int id;
    private int age;
    private String name;
 
    public User(int id, int age, String name) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
 
    @Override
    public int compareTo(User user) {
        return user.getAge() - this.getAge();
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class SortTest {
 
    public static void main(String[] args) {
        // 初始化数据
        List list = new ArrayList() {{
            add(new User(1, 43, "北京"));
            add(new User(5, 16, "天津"));
            add(new User(3, 33, "石家庄"));
            add(new User(4, 27, "深圳"));
        }};
 
        // 使用Comparable进行排序
        Collections.sort(list);
        list.forEach(p -> {System.out.println(p);});
 
    }
}

 结果如下图所示：

3.使用Stream流排序

3.1 stream的升序降序

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
 
public class SortTest {
 
    public static void main(String[] args) {
        // 初始化数据
        List list = new ArrayList() {{
            add(new User(1, 43, "北京"));
            add(new User(5, 16, "天津"));
            add(new User(3, 33, "石家庄"));
            add(new User(4, 27, "深圳"));
        }};
 
        // 使用Stream排序，默认升序，使用reversed为降序
        list = list.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
 
        list.forEach(p -> System.out.println(p));
 
    }
}

3.2 stream中的组合排序

        // 使用Stream排序的组合排序,使用age降序，再使用id升序
        list = list.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getId)).collect(Collectors.toList());

3.3 stream中null的处理

若类中有null的情况，可用nullsFirst或nullsLast等方法进行处理（将User类中的int类型修改为了Integer,int类型不允许为null，默认为0），代码示例如下

import lombok.Data;
 
@Data
public class User{
 
    private Integer id;
    private Integer age;
    private String name;
 
    public User(Integer id, Integer age, String name) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
 
public class SortTest {
 
    public static void main(String[] args) {
        // 初始化数据
        List list = new ArrayList() {{
            add(new User(1, 43, "北京"));
            add(new User(5, 16, "天津"));
            add(new User(3, 33, "石家庄"));
            add(new User(4, null, "深圳"));
        }};
 
        // 使用Stream排序，默认升序，使用reversed为降序，nullsXXX处理null的情况
        list = list.stream().sorted(Comparator.comparing(User::getAge,
                        Comparator.nullsFirst(Integer::compareTo)))
                .collect(Collectors.toList());
        list.forEach(p -> System.out.println(p));
 
    }
}

结果如下所示：