一、基本类型排序
1.list中只有数字或字符串
//升序排序 List<T> ,T为数字或字符串
Collections.sort(list);
//降序排序
Collections.sort(list,Collections.reverseOrder());
2.list中为对象
基于jdk.18
java
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比较器
java
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<User> list = new ArrayList<User>() {{
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<User> {
@Override
//正数排前
public int compare(User p1, User p2) {
return p1.getAge() - p2.getAge();
}
}
结果如下图所示:
2.1.2匿名类比较器
比较器Comparator
可以使用匿名类的方式,更加简洁的实现排序,代码如下:
java
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<User> list = new ArrayList<User>() {{
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<User>(){
@Override
//倒数排前
public int compare(User p1, User p2) {
return p2.getAge() - p1.getAge();
}
});
// 打印 list 集合
list.forEach(p -> {System.out.println(p);});
}
}
结果如下图所示
2.1.3 静态内部类
java
//按照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
是类内部的比较方法,需要修改比较类的内部方法,实现如下:
java
import lombok.Data;
@Data
public class User implements Comparable<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;
}
@Override
public int compareTo(User user) {
return user.getAge() - this.getAge();
}
}
java
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SortTest {
public static void main(String[] args) {
// 初始化数据
List<User> list = new ArrayList<User>() {{
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的升序降序
java
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<User> list = new ArrayList<User>() {{
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中的组合排序
java
// 使用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),代码示例如下
java
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;
}
}
java
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<User> list = new ArrayList<User>() {{
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));
}
}
结果如下所示: