Lambda表达式-实际应该用-List.sort()排序

本文通过实例演示了如何使用Java中的List.sort()方法结合Lambda表达式进行列表排序,对比了传统Comparator实现与Lambda表达式的不同,展示了升序与降序的排序过程。

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

/**
 * @ClassName Demo
 * @Description Lambda表达式--List.sort()排序
 * @author TianJianWen
 * @data 2019年11月14日下午3:27:26
 *
 */
public interface Demo_List_Sort {

    public static void main(String[] args) {
        // List.sort() 排序
        List<Person> list = new ArrayList<>();
        list.add(new Person(3));
        list.add(new Person(1));
        list.add(new Person(8));
        list.add(new Person(7));
        list.add(new Person(5));
        System.err.print("默认顺序:");
        for (Person person : list) {
            System.out.print(person.getHeight()+", ");
        }
        System.err.println();
        // 1.传统方式使用 - 升序
        list.sort(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                // o1和o2比较 1:大于 0:相等 -1:小于
                // 颠倒结果就是降序
                return o1.getHeight().compareTo(o2.getHeight());
            }
        });
        System.err.print("传统方式顺序:");
        for (Person person : list) {
            System.out.print(person.getHeight()+", ");
        }
        System.err.println();
        /**
         * 2.Lambda使用
         */
        //  - 降序
        list.sort((o1, o2) -> o2.getHeight().compareTo(o1.getHeight()));
        System.err.print("Lambda表达式》降序顺序:");
        for (Person person : list) {
            System.out.print(person.getHeight()+", ");
        }
        //  - 升序
        System.err.println();
        list.sort((o1, o2) -> o1.getHeight().compareTo(o2.getHeight()));
        System.err.print("Lambda表达式》升序顺序:");
        for (Person person : list) {
            System.out.print(person.getHeight()+", ");
        }
    }
}

class Person {

    public Person(Integer height) {
        this.height = height;
    }

    private Integer height;

    public Integer getHeight() {
        return height;
    }

    public void setHeight(Integer height) {
        this.height = height;
    }
}

<think>我们被要求解释如何在排序中使用lambda表达式,并提供示例代码。根据引用[1][2][3][4][5],我们可以总结如下: 引用[1]和[2]主要说明了在Java中使用Lambda表达式对集合进行排序,特别是用Lambda表达式替代匿名类来定义Comparator。 引用[3]则展示了在C++中使用lambda表达式自定义sort排序方法,特别是对结构体或类对象的排序。 因此,我们将分别给出Java和C++两种语言中的示例。 在Java中,使用Lambda表达式进行排序通常用于替代Comparator的匿名内部类。在Java 8及以后,List接口有sort方法,Collections类也有sort方法,都可以接受一个Comparator,而Comparator可以用Lambda表达式来实现。 在C++中,std::sort函数可以接受一个比较函数或函数对象,而lambda表达式正好可以定义一个函数对象,因此可以直接作为比较器传入。 下面我们分别给出两种语言的详细说明和示例。 一、Java中使用Lambda表达式排序 1. 对基本类型(如String、Integer等)的列表排序 升序排序: 引用[2]中示例:Collections.sort(names, (a, b) -> a.compareToIgnoreCase(b)); 也可以使用List自带的sort方法: names.sort((a, b) -> a.compareTo(b)); // 区分大小写 降序排序:只需调换两个参数的位置或改变比较逻辑。 names.sort((a, b) -> b.compareTo(a)); 2. 对自定义对象列表排序 假设有一个Person类: class Person { private String name; private int age; // 构造方法和getter/setter省略 } 按年龄升序排序List<Person> people = ...; people.sort((p1, p2) -> p1.getAge() - p2.getAge()); 按年龄降序排序: people.sort((p1, p2) -> p2.getAge() - p1.getAge()); 3. 使用Comparator的comparing方法(更简洁) 我们还可以使用Comparator.comparing方法,结合Lambda表达式: people.sort(Comparator.comparing(p -> p.getName())); // 按姓名升序 降序则可以使用reversed方法: people.sort(Comparator.comparing(Person::getName).reversed()); 二、C++中使用Lambda表达式排序 引用[3]中给出了一个对结构体向量排序的例子。 基本语法: sort(容器起始迭代器, 容器结束迭代器, lambda表达式); lambda表达式格式: [](参数类型 参数1, 参数类型 参数2) -> bool { // 比较规则:返回true表示第一个参数应该排在第二个参数前面 return ...; } 示例1:对整数向量降序排序 vector<int> nums = {3, 1, 4, 2}; sort(nums.begin(), nums.end(), [](int a, int b) { return a > b; // 降序:a>b时,a排在b前面 }); 示例2:对自定义结构体排序 如引用[3]中的cmpstr结构体,按照x的值从小到大排序(升序): sort(cmpstr_ins.begin(), cmpstr_ins.end(), [](cmpstr m, cmpstr n) { return m.x < n.x; // 升序:如果m.x小于n.x,则m排在n前面 }); 注意:在C++中,lambda表达式可以捕获外部变量(如果需要的话),但在排序中通常不需要捕获。 下面我们给出完整的代码示例。 注意:由于用户要求的是sort排序中使用lambda表达式,我们将分别用Java和C++写两个完整的示例。</think>### Lambda表达式排序中的应用详解与示例 Lambda表达式排序操作中主要用于**自定义比较规则**,替代传统的比较器实现,使代码更加简洁直观。下面分别通过Java和C++示例说明具体使用方法: #### 一、Java中使用Lambda表达式排序 在Java中,Lambda表达式主要用于替代`Comparator`接口的匿名实现类,简化集合排序操作。 1. **基本类型排序** ```java // 字符串列表排序 List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); // 升序排序 Collections.sort(names, (a, b) -> a.compareTo(b)); // [Alice, Bob, Charlie][^2] // 降序排序 Collections.sort(names, (a, b) -> b.compareTo(a)); // [Charlie, Bob, Alice][^1] ``` 2. **对象属性排序** ```java class Person { String name; int age; // 构造方法和getter省略 } List<Person> people = Arrays.asList( new Person("Alice", 25), new Person("Bob", 30), new Person("Charlie", 20) ); // 按年龄升序排序 people.sort((p1, p2) -> p1.getAge() - p2.getAge()); // 结果:Charlie(20) -> Alice(25) -> Bob(30)[^4] // 按姓名长度降序排序 people.sort((p1, p2) -> Integer.compare(p2.getName().length(), p1.getName().length())); // 结果:Charlie(7) -> Alice(5) -> Bob(3) ``` #### 二、C++中使用Lambda表达式排序 在C++中,Lambda表达式作为`std::sort`的第三个参数,用于定义自定义比较规则。 1. **基本类型排序** ```cpp #include <algorithm> #include <vector> std::vector<int> nums = {3, 1, 4, 2}; // 升序排序 std::sort(nums.begin(), nums.end(), [](int a, int b) { return a < b; }); // {1,2,3,4}[^3] // 降序排序 std::sort(nums.begin(), nums.end(), [](int a, int b) { return a > b; }); // {4,3,2,1} ``` 2. **结构体/类对象排序** ```cpp struct Employee { std::string name; int salary; }; std::vector<Employee> employees = { {"Alice", 5000}, {"Bob", 3000}, {"Charlie", 7000} }; // 按薪资升序排序 std::sort(employees.begin(), employees.end(), [](const Employee& a, const Employee& b) { return a.salary < b.salary; }); // 结果:Bob(3000) -> Alice(5000) -> Charlie(7000)[^3] // 按名字长度降序排序 std::sort(employees.begin(), employees.end(), [](const Employee& a, const Employee& b) { return a.name.length() > b.name.length(); }); // 结果:Charlie(7) -> Alice(5) -> Bob(3) ``` #### 三、高级用法 1. **多条件排序** ```java // Java示例:先按薪资降序,再按名字升序 people.sort((p1, p2) -> { if (p1.getSalary() != p2.getSalary()) { return p2.getSalary() - p1.getSalary(); } return p1.getName().compareTo(p2.getName()); }); ``` 2. **捕获外部变量** ```cpp // C++示例:使用外部阈值过滤排序 int threshold = 4000; std::sort(employees.begin(), employees.end(), [threshold](const Employee& a, const Employee& b) { if (a.salary < threshold && b.salary >= threshold) return true; if (a.salary >= threshold && b.salary < threshold) return false; return a.name < b.name; }); ``` #### 关键点总结 1. **返回值规则**: - 返回`true`表示第一个元素应排在第二个元素之前 - Java中:`(a,b) -> a<b` 表示升序 - C++中:`[](a,b){return a<b;}` 表示升序 2. **优势对比**: | 方式 | 代码量 | 可读性 | 维护性 | |------|--------|--------|--------| | 传统比较器 | 多行代码 | 较低 | 一般 | | **Lambda表达式** | 单行实现 | **高** | **优** | 3. **使用场景**: - 需要快速实现临时排序规则 - 排序逻辑简单且无需复用 - 函数式编程环境(如Java Stream API) Lambda表达式通过将比较逻辑内联到排序调用中,显著减少了样板代码,提高了代码可读性,特别适合在集合操作中实现自定义排序规则[^1][^2][^3][^4]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值