Android List按属性排序方法总结工具类

tangweiguo030519872025-03-09 14:10

在 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()));

  1. 使用 List.sort() 方法
    你也可以直接使用 List.sort() 方法进行排序：

    personList.sort((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()));

  2. 使用 Comparator.comparing() 方法
    Java 8 引入了 Comparator.comparing() 方法，可以更简洁地根据对象的属性进行排序：

    personList.sort(Comparator.comparing(Person::getAge));

  3. 降序排序
    如果你想进行降序排序，可以使用 Comparator.reversed() 方法：

    personList.sort(Comparator.comparing(Person::getAge).reversed());

  4. 多属性排序
    如果你想根据多个属性进行排序，可以使用 Comparator.thenComparing() 方法。例如，先根据 age 排序，再根据 name 排序：

    personList.sort(Comparator.comparing(Person::getAge).thenComparing(Person::getName));

  5. 使用 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 工具类具有以下特点：

链式调用：支持流式编程，代码更简洁。

空安全：避免空指针异常。

多属性排序：支持按多个属性排序。

高可读性：方法命名清晰，注释详细。

相关推荐
*星星之火*3 小时前
【GPT入门】第5课 思维链的提出与案例
android·gpt
EasyCVR3 小时前
EasyRTC嵌入式视频通话SDK的跨平台适配，构建web浏览器、Linux、ARM、安卓等终端的低延迟音视频通信
android·arm开发·网络协议·tcp/ip·音视频·webrtc
韩家老大4 小时前
RK Android14 在计算器内输入特定字符跳转到其他应用
android
张拭心6 小时前
2024 总结，我的停滞与觉醒
android·前端
夜晚中的人海6 小时前
【C语言】------ 实现扫雷游戏
android·c语言·游戏
ljx14000525507 小时前
Android AudioFlinger（一）——初识AndroidAudio Flinger
android
ljx14000525507 小时前
Android AudioFlinger（四）—— 揭开PlaybackThread面纱
android
Codingwiz_Joy7 小时前
Day04 模拟原生开发app过程 Androidstudio+逍遥模拟器
android·安全·web安全·安全性测试
叶羽西7 小时前
Android15 Camera框架中的StatusTracker
android·camera框架
梦中千秋7 小时前
安卓设备root检测与隐藏手段
android
热门推荐
01DeepSeek各版本说明与优缺点分析02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03如何在WPS和Word/Excel中直接使用DeepSeek功能04苍穹外卖面试总结05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06本地部署DeepSeek教程（Mac版本）07Coze扣子平台完整体验和实践（附国内和国际版对比）08Windows 11 安装 Dify 完整指南 非docker环境09保姆级教程：利用Ollama与Open-WebUI本地部署 DeedSeek-R1大模型10macOS 上部署 RAGFlow