Android List按属性排序方法总结工具类
在 Android 中，你可以使用 Collections.sort() 方法或 List.sort() 方法对 List 进行排序。为了根据指定属性排序，你可以使用 Comparator 来定义排序规则。以下是几种常见的排序方式：
1. 使用 Comparator 进行排序
假设你有一个 Person 类，并且你想根据 age 属性对 List 进行排序。
假设你有一个 Person 类，并且你想根据 age 属性对 List 进行排序。
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
你可以使用 Comparator 来根据 age 属性进行排序：
List<Person> personList = new ArrayList<>();
personList.add(new Person("Alice", 30));
personList.add(new Person("Bob", 25));
personList.add(new Person("Charlie", 35));
// 使用 Comparator 根据 age 排序
Collections.sort(personList, new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return Integer.compare(p1.getAge(), p2.getAge());
}
});
或者使用 Java 8 的 Lambda 表达式简化代码：
Collections.sort(personList, (p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()));
- 使用 List.sort() 方法
你也可以直接使用 List.sort() 方法进行排序：
personList.sort((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()));
- 使用 Comparator.comparing() 方法
Java 8 引入了 Comparator.comparing() 方法，可以更简洁地根据对象的属性进行排序：
personList.sort(Comparator.comparing(Person::getAge));
- 降序排序
如果你想进行降序排序，可以使用 Comparator.reversed() 方法：
personList.sort(Comparator.comparing(Person::getAge).reversed());
- 多属性排序
如果你想根据多个属性进行排序，可以使用 Comparator.thenComparing() 方法。例如，先根据 age 排序，再根据 name 排序：
personList.sort(Comparator.comparing(Person::getAge).thenComparing(Person::getName));
- 使用 Kotlin 进行排序
如果你使用 Kotlin，排序会更加简洁：
val personList = listOf(
Person("Alice", 30),
Person("Bob", 25),
Person("Charlie", 35)
)
// 根据 age 排序
val sortedList = personList.sortedBy { it.age }
// 降序排序
val sortedListDesc = personList.sortedByDescending { it.age }
以下是进一步优化后的工具类：
为了进一步优化代码，我们可以从以下几个方面进行改进：
减少方法参数：通过引入链式调用的方式，让代码更符合现代编程风格。
增强可读性：通过方法命名和注释，让代码更直观易懂。
支持链式调用：通过返回 List 本身，支持链式调用，方便在流式编程中使用。
支持空安全：增加对空列表和空属性的处理，避免空指针异常。
工具类：ListSorter
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
public final class ListSorter {
/**
* 私有构造函数，禁止实例化
*/
private ListSorter() {
throw new UnsupportedOperationException("Utility class, do not instantiate!");
}
/**
* 对 List 按照指定属性进行排序（支持升序或降序）
*
* @param list 需要排序的列表
* @param keyExtractor 用于提取排序属性的函数
* @param ascending 是否升序排序（true：升序，false：降序）
* @param <T> 列表元素类型
* @param <U> 排序属性的类型（必须实现 Comparable 接口）
* @return 排序后的列表（支持链式调用）
*/
public static <T, U extends Comparable<? super U>> List<T> sort(List<T> list, Function<T, U> keyExtractor, boolean ascending) {
if (list == null || list.isEmpty() || keyExtractor == null) {
return list;
}
Comparator<T> comparator = Comparator.comparing(keyExtractor);
if (!ascending) {
comparator = comparator.reversed();
}
list.sort(comparator);
return list;
}
/**
* 对 List 按照指定属性进行升序排序
*
* @param list 需要排序的列表
* @param keyExtractor 用于提取排序属性的函数
* @param <T> 列表元素类型
* @param <U> 排序属性的类型（必须实现 Comparable 接口）
* @return 排序后的列表（支持链式调用）
*/
public static <T, U extends Comparable<? super U>> List<T> sortAscending(List<T> list, Function<T, U> keyExtractor) {
return sort(list, keyExtractor, true);
}
/**
* 对 List 按照指定属性进行降序排序
*
* @param list 需要排序的列表
* @param keyExtractor 用于提取排序属性的函数
* @param <T> 列表元素类型
* @param <U> 排序属性的类型（必须实现 Comparable 接口）
* @return 排序后的列表（支持链式调用）
*/
public static <T, U extends Comparable<? super U>> List<T> sortDescending(List<T> list, Function<T, U> keyExtractor) {
return sort(list, keyExtractor, false);
}
/**
* 对 List 按照多个属性进行排序（支持升序或降序）
*
* @param list 需要排序的列表
* @param ascending 是否升序排序（true：升序，false：降序）
* @param keyExtractors 用于提取排序属性的函数数组
* @param <T> 列表元素类型
* @param <U> 排序属性的类型（必须实现 Comparable 接口）
* @return 排序后的列表（支持链式调用）
*/
@SafeVarargs
public static <T, U extends Comparable<? super U>> List<T> sortByMultipleKeys(List<T> list, boolean ascending, Function<T, U>... keyExtractors) {
if (list == null || list.isEmpty() || keyExtractors == null || keyExtractors.length == 0) {
return list;
}
Comparator<T> comparator = Comparator.comparing(keyExtractors[0]);
for (int i = 1; i < keyExtractors.length; i++) {
comparator = comparator.thenComparing(keyExtractors[i]);
}
if (!ascending) {
comparator = comparator.reversed();
}
list.sort(comparator);
return list;
}
}
优化点
链式调用：
所有方法都返回排序后的 List，支持链式调用，方便在流式编程中使用。
例如：ListSorter.sortAscending(list, Person::getAge).forEach(System.out::println);
空安全：
增加了对 list 和 keyExtractor 的空值检查，避免空指针异常。
如果输入为空，直接返回原列表。
方法命名更直观：
方法名如 sortAscending 和 sortDescending 更直观地表达了功能。
支持多属性排序：
通过 sortByMultipleKeys 方法，支持按多个属性排序。
工具类设计：
工具类为 final，并私有化构造函数，避免被实例化。
使用示例：
使用 ListSorter 对 List 进行排序：
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Person> personList = new ArrayList<>();
personList.add(new Person("Alice", 30));
personList.add(new Person("Bob", 25));
personList.add(new Person("Charlie", 35));
personList.add(new Person("Alice", 20));
// 按年龄升序排序
ListSorter.sortAscending(personList, Person::getAge)
.forEach(System.out::println);
// 按年龄降序排序
ListSorter.sortDescending(personList, Person::getAge)
.forEach(System.out::println);
// 按姓名升序排序
ListSorter.sortAscending(personList, Person::getName)
.forEach(System.out::println);
// 按年龄升序排序，年龄相同则按姓名升序排序
ListSorter.sortByMultipleKeys(personList, true, Person::getAge, Person::getName)
.forEach(System.out::println);
}
}
输出结果
按年龄升序排序:
Person{name='Bob', age=25}
Person{name='Alice', age=30}
Person{name='Charlie', age=35}
按年龄降序排序:
Person{name='Charlie', age=35}
Person{name='Alice', age=30}
Person{name='Bob', age=25}
按姓名升序排序:
Person{name='Alice', age=30}
Person{name='Alice', age=20}
Person{name='Bob', age=25}
Person{name='Charlie', age=35}
按年龄和姓名升序排序:
Person{name='Alice', age=20}
Person{name='Bob', age=25}
Person{name='Alice', age=30}
Person{name='Charlie', age=35}
总结
优化后的 ListSorter 工具类具有以下特点：
链式调用：支持流式编程，代码更简洁。
空安全：避免空指针异常。
多属性排序：支持按多个属性排序。
高可读性：方法命名清晰，注释详细。