lambda表达式详解

原创已于 2025-08-21 22:02:44 修改 · 1.4k 阅读

·

0

·

CC 4.0 BY-SA版权

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

文章标签：

#java #开发语言

于 2020-06-26 22:56:52 首次发布

Java基础专栏收录该内容

8 篇文章

订阅专栏

本文深入探讨Java Stream API的应用，包括lambda表达式优化、数组转换、flatMap操作、排序策略、anyMatch使用、Optional处理、reduce规约、分组与计数等高级特性，为开发者提供实用的代码示例与最佳实践。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

目录

lambda表达式与传统接口的对比

数组转化为管道流

自定义分组

多字段去重

lambda表达式与传统接口的对比

public class lambdaTest {
    interface Print{
        void print(String str);
    }
    void printSomeThing(String str, Print print){
        print.print(str);
    }


    public static void main(String[] args) {
        lambdaTest test = new lambdaTest();
        //原始写法
        Print print = new Print() {
            @Override
            public void print(String str) {
                System.out.println(str);
            }
        };
        //lambda写法
        Print print01 = v-> System.out.println(v);
        test.printSomeThing("sdfadf", print);
    }
}

数组转化为管道流

        // 转化为管道流
        String[] strArr = {"adfas","safdasf","sffwer"};
        List<String> list1 = Stream.of(strArr)
                .filter(v->v.startsWith("a"))
                .collect(Collectors.toList());
        System.out.println(list1);

flatMap

List<String> list = Arrays.asList("adfas","safdasf","sffwer");
List<String> strings = Arrays.asList(strArr);
        List<String[]> res1 = strings.stream().map(v->{
            return v.split("");
        }).collect(Collectors.toList());
        //System.out.println(res1);

        // 把流拍平
        List<String> res2 = strings.stream()
                //.flatMap(v->Arrays.stream(v.split("")))
                .flatMap(v->Stream.of(v.split("")))
                .collect(Collectors.toList());
        System.out.println(res2);


list套string[]时:

List<String> res = lists.stream().flatMap(Arrays::stream).collect(Collectors.toList());


list套list时:

Model model1 = new Model("1");
Model model2 = new Model("2");
List<Model> list01 = Lists.newArrayList(model1);
List<Model> list02 = Lists.newArrayList(model2);
List<Model> list03 = Lists.newArrayList(model1, model1);
List<List<Model>> lists = Lists.newArrayList(list01, list02, list03);

List<Model> res = lists.stream().flatMap(List::stream).collect(Collectors.toList());

排序规则

//都是正序  不加reserved
//都是倒序  最后一个加reserved
//先倒序(reserved) 然后正序
//先正序(reserved) 然后倒序(reserved)

//排序
        Car01 car01 = new Car01("A,Asdf,", "a,a");
        Car01 car02 = new Car01("B,Bsfd,sf", "b,b");
        Car01 car03 = new Car01("C,C", "cc");
        Car01 car04 = new Car01("D,D", "dd");
        Car01 car05 = new Car01("E,E", "dd");
        Car01 car06 = new Car01("E,E", "aa");

        List<Car01> list03 = new ArrayList<>();
        list03.add(car01);
        list03.add(car02);
        list03.add(car03);
        list03.add(car04);
        list03.add(car05);
        list03.add(car06);
        list03.sort(Comparator.comparing(Car01::getAge)
                .reversed()
                .thenComparing(Car01::getName)
                .reversed()

        );



//简单排序
Set<String> transTimeSet = Sets.newHashSet("2022-10-10","2022-01-01","2022-10-02","2022-08-01");
List<String> transTimeList = Lists.newArrayList(transTimeSet);
transTimeList.sort(Comparator.naturalOrder()); // 正序
System.out.println(transTimeList);

-- 输出
[2022-01-01, 2022-08-01, 2022-10-02, 2022-10-10]


-- 自定义排序规则(处理字符串转数字排序)
analyzeResps = analyzeResps.stream().sorted(Comparator.comparing(BudgetAnalyzeResp::getBudgetMonth,(s1,s2)->{
            return Integer.valueOf(s1)-Integer.valueOf(s2);
        })


 // status=1 在前  status=-1 在后，如果都相同则 vendorId 大的在前
                vendorInfos.sort((s1, s2) -> {
                    Integer status1 = s1.getStatus();
                    Integer status2 = s2.getStatus();
                    if (status1 == 1 && status2 != 1) {
                        return -1;   // 假设 1在左  -1在右。refunn -1代表接受目前顺序
                    } else if (status1 != 1 && status2 == 1) {
                        return 1;
                    } else {
                        // 假设 s1在左  s2在右。如果s1 > s2 则return -1 接受目前顺序
                                              如果s1 < s2 则return 1 不接受目前顺序,需要调换位置==>最终变成s2 在左 s1在右，达到倒序排的效果
                        return s2.getVendorId().compareTo(s1.getVendorId());
                    }
                });

anyMatch

Boolean flag01 = list03.stream().anyMatch(v->v.getAge().contains("a"));
        Boolean flag02 = list03.stream().allMatch(v->v.getAge().contains("a"));
        Boolean flag03 = list03.stream().noneMatch(v->v.getAge().contains("a"));
        System.out.println(flag01);
        System.out.println(flag02);
        System.out.println(flag03);

Optional

//查找并获取第一个
        Optional<Car01> optional01 = list03.stream().filter(v->v.getAge().startsWith("a")).findFirst();
        if(optional01.isPresent()){
            System.out.println(optional01.get());
        }
        //查找并获取任意一个
        Optional<Car01> optional02 = list03.stream().filter(v->v.getAge().startsWith("e")).findAny();
        if(optional02.isPresent()){
            System.out.println(optional02.get());
        }
        //NPE
        //System.out.println(optional02.get());
        // 是否存在第一个
        Boolean flag04 = list03.stream().filter(v->v.getAge().startsWith("z"))
                .findFirst()
                .isPresent();
        System.out.println(flag04);
        // 是否存在任意一个
        Boolean flag05 = list03.stream().filter(v->v.getAge().startsWith("z"))
                .findFirst()
                .isPresent();
        System.out.println("flag05--->"+flag05);
        // 如果存在
        list03.stream().filter(v->v.getAge().startsWith("a"))
                .findFirst()
                .ifPresent(v->System.out.println(v));
        // 如果不存在还想给默认值
        list03.stream().filter(v->v.getAge().startsWith("a"))
                .findFirst()
                .orElse(new Car01("aaa", "bbb"));

        //判断是否为空然后进行map里面的操作如果没有值存在则返回orElse的值
        Optional.ofNullable(car5).map(Car::getAge).orElse(11);

reduce 规约

//规约
        List<Integer> nums = Arrays.asList(1,2,3,4);
        Integer total01 = nums.stream().reduce(0, (s1, ele)->s1 + ele);
        System.out.println(total01);

        Integer total02 = nums.stream().reduce(0, Integer::sum);
        System.out.println(total02);

        //字符串累加
        String total03 = list03.stream().map(Car01::getAge).reduce("", (o1, o2)->o1 + o2);
        System.out.println(total03);

        //并行字符串累加
        String total04 = list03.stream().parallel().map(Car01::getAge).reduce("", (o1, o2)->o1 + o2);
        System.out.println(total03);

        //并行后合并
        Integer total05 = nums.stream().parallel().reduce(0, Integer::sum, Integer::sum);
        System.out.println(total05);
        //reduce直接操作对象(String::concat 指定加和作为下一次的subTotal)
        String total06 = list03.stream().parallel()
                .reduce("", (subTotal, emp)->subTotal + emp.getAge(),String::concat);
        System.out.println(total05);

分组后sum

public class Model {

    private String clientCode;

    private Integer cnt;
}

key--clientCode  value--sum(cnt)
Map<String, Integer> userMap = models.stream().collect(Collectors.groupingBy(v -> v.getClientCode(), Collectors.reducing(0, Model::getCnt, Integer::sum)));

分组后cnt

public class Entity {

    private String userId;

    private String platform;
}


key-->userId value-->cnt
Map<String, Long> collect = entitys.stream().collect(Collectors.groupingBy(v -> v.getUserId(), Collectors.counting()));

自定义分组

@Data
public class CustTag {
    private Long id;
    private Integer num;
    private String name;
    private String category;

    public CustTag(Long id, Integer num, String name, String category) {
        this.id = id;
        this.num = num;
        this.name = name;
        this.category = category;
    }
}


public class GroupTest {
    public static void main(String[] args) {
        CustTag custTag1 = new CustTag(1L, 1, "1年", "普通");
        CustTag custTag2 = new CustTag(2L, 3, "半年", "普通");
        CustTag custTag3 = new CustTag(3L, 1, "3个月", "VIP");
        CustTag custTag4 = new CustTag(4L, 4, "1个月", "VIP");
        CustTag custTag5 = new CustTag(5L, 5, "天天", "GVP");
        List<CustTag> custTagList = Lists.newArrayList(custTag1, custTag2, custTag3, custTag4, custTag5);

        Map<String, List<CustTag>> custTagMap = custTagList.stream()
                .collect(Collectors.groupingBy(s -> {
                    if (s.getNum() == 1) {
                        return "R1";
                    }
                    if (s.getNum() == 3) {
                        return "R2";
                    }
                    if (s.getNum() == 4) {
                        return "R3";
                    }
                    return "R4";
                }));

        System.out.println(JSON.toJSONString(custTagMap));
    }
}

-- 输出

分页

List<Integer> list = Lists.newArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        // 跳过1个 保留6个
        List<Integer> res1 = list.stream().skip(1).limit(6).collect(Collectors.toList());
        // 跳过1个 保留1个
        List<Integer> res2 = 
list.stream().skip(1).limit(1).collect(Collectors.toList());
        // 跳过6个 保留10个
        List<Integer> res3 = 
list.stream().skip(6).limit(10).collect(Collectors.toList());

        System.out.println("res1:"+res1);
        System.out.println("res2:"+res2);
        System.out.println("res3:"+res3);

输出:
res1:[2, 3, 4, 5]
res2:[2]
res3:[]

多字段去重

public class FlightTicketInfo {

    private String orderNumber;

    private String userName;

    private String age;

    public FlightTicketInfo(String orderNumber, String userName, String age) {
        this.orderNumber = orderNumber;
        this.userName = userName;
        this.age = age;
    }

    @Override
    public String toString() {
        return "FlightTicketInfo{" +
                "orderNumber='" + orderNumber + '\'' +
                ", userName='" + userName + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    public String getOrderNumber() {
        return orderNumber;
    }

    public String getUserName() {
        return userName;
    }

    public String getAge() {
        return age;
    }

    public static void main(String[] args) {
        List<FlightTicketInfo> infoList = new ArrayList<>();
        infoList.add(new FlightTicketInfo("11111", "xiaoming", "22"));
        infoList.add(new FlightTicketInfo("22222", "xiaoming", "22"));
        infoList.add(new FlightTicketInfo("33333", "xiaoming", "23"));
        infoList.add(new FlightTicketInfo("11111", "xiaoming", "22"));
        ArrayList<FlightTicketInfo> collect = infoList.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getUserName() + f.getAge()))), ArrayList::new));

        System.out.println(JSON.toJSONString(collect));
    }
    
}
-- 输出
[{"age":"22","orderNumber":"11111","userName":"xiaoming"},{"age":"23","orderNumber":"33333","userName":"xiaoming"}]

评论 1

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

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