Lambda 表达式练习

清风絮柳2024-06-03 9:12

目录

[sorted() 四种排序](#sorted() 四种排序)

[List 转 Map](#List 转 Map)

[map 映射](#map 映射)

[对象中 String 类型属性为空的字段赋值为 null](#对象中 String 类型属性为空的字段赋值为 null)

BiConsumer,>

[T reduce(T identity, BinaryOperator accumulator)](#T reduce(T identity, BinaryOperator accumulator))

[allMatch(Predicate p)](#allMatch(Predicate p))

[groupingBy(Function f)](#groupingBy(Function f))

[flatMap(Function f)](#flatMap(Function f))

[Optional.ofNullable(T t) 和 T orElse(T other)](#Optional.ofNullable(T t) 和 T orElse(T other))

先来写个基本类

java 复制代码 
public class LambdaTest {
    @Data
    class Student {
        private Integer id;
        private String name;
        private Integer age;

        public Student(Integer id, String name, Integer age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }
    }

    public List<Student> getStudents() {
        List<Student> list = new ArrayList<>();
        list.add(new Student(100, "小明", 10));
        list.add(new Student(101, "小红", 11));
        list.add(new Student(102, "小李", 12));
        list.add(new Student(103, "小王", 13));
        list.add(new Student(104, "小张", 14));
        list.add(new Student(105, "小五", 15));
        list.add(new Student(106, "小华", 16));
        return list;
    }
}

sorted() 四种排序

java 复制代码 
@Test
public void sortedTest() {
    List<Student> students = this.getStudents();
    //正序：常规写法
    List<Student> collect = students.stream().sorted((a1, a2) -> Integer.compare(a1.getAge(), a2.getAge())).collect(Collectors.toList());
    collect.forEach(System.out::println);
    System.out.println();
    //正序：lambda 简写
    List<Student> collectComparator = students.stream().sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());
    collectComparator.forEach(System.out::println);
    System.out.println();

    //倒序：常规写法
    List<Student> collectReversed = students.stream().sorted((a1, a2) -> Integer.compare(a2.getAge(), a1.getAge())).collect(Collectors.toList());
    collectReversed.forEach(System.out::println);
    System.out.println();
    //正序：lambda 简写
    List<Student> collectComparatorReversed = students.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
    collectComparatorReversed.forEach(System.out::println);
}

List 转 Map

java 复制代码 
@Test
public void listToMapTest() {
    List<Student> students = this.getStudents();
    Map<Integer, Student> collect = students.stream().collect(Collectors.toMap(Student::getId, s -> s, (s1, s2) -> s1));
    collect.keySet().forEach(key -> System.out.println(String.format("key：%s，value：%s", key, collect.get(key))));
}

map 映射

java 复制代码 
 @Test
    public void mapTest() {
        List<Student> students = this.getStudents();
//        List<Student> students = Lists.newArrayList(new Student(null, "小炎姬", 5));
        Integer id = students.stream().map(Student::getId).max(Integer::compareTo).orElse(0);
        System.out.println(id);
    }

对象中 String 类型属性为空的字段赋值为 null

java 复制代码 
public static <T> void stringEmptyToNull(T t) {
    Class<?> clazz = t.getClass();

    Field[] fields = clazz.getDeclaredFields();
    Arrays.stream(fields)
        .filter(f -> f.getType() == String.class)
        .filter(f -> {
            try {
                f.setAccessible(true);
                String value = (String) f.get(t);
                return StringUtils.isEmpty(value);
            } catch (Exception ignore) {
                return false;
            }
        })
        .forEach(field -> {
            try {
                field.setAccessible(true);
                field.set(t, null);
                } catch (Exception ignore) {
            }
        });
}

BiConsumer<T, U>

XML 复制代码 
<!-- lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>
        
<!-- guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>28.2-jre</version>
</dependency>
java 复制代码 
/**
 * @author vincent
 */
public class LambdaTest {
    @Data
    private static class Student {
        private Integer id;
        private String name;
        private Integer age;
        private Integer interestType;
        private List<Hobby> hobbies;
        private List<Fancy> fancies;
        private Subject subject;

        private Student(Integer id, String name, Integer age, Integer interestType, List<Hobby> hobbies, List<Fancy> fancies, Subject subject) {
            this.id = id;
            this.name = name;
            this.age = age;
            this.interestType = interestType;
            this.hobbies = hobbies;
            this.fancies = fancies;
            this.subject = subject;
        }

    }

    enum InterestType {
        HOBBY(1, "兴趣"),
        FANCY(2, "喜好");
        private Integer code;
        private String message;

        InterestType(Integer code, String message) {
            this.code = code;
            this.message = message;
        }

        public Integer getCode() {
            return code;
        }

        public static InterestType getInterestTypeByCode(int code) {
            return Arrays.stream(InterestType.values()).filter(interestType -> interestType.getCode() == code).findFirst().orElse(null);
        }

    }

    @Data
    private static class Hobby {
        private String basketball;
        private String running;
        private String drinking;

        private Hobby(String basketball, String running, String drinking) {
            this.basketball = basketball;
            this.running = running;
            this.drinking = drinking;
        }
    }

    @Data
    private static class Fancy {
        private String dance;
        private String takePhotos;
        private String meetGirls;

        private Fancy(String dance, String takePhotos, String meetGirls) {
            this.dance = dance;
            this.takePhotos = takePhotos;
            this.meetGirls = meetGirls;
        }
    }

    @Data
    private static class Subject {
        private String english;
        private String chinese;
        private String mathematics;

        private Subject(String english, String chinese, String mathematics) {
            this.english = english;
            this.chinese = chinese;
            this.mathematics = mathematics;
        }
    }

    private List<Student> getStudent() {
        List<Student> list = Lists.newArrayList();
        list.add(new Student(100, "小明", 10, 1,
                Lists.newArrayList(
                        new Hobby("篮球", "跑步", "喝酒"),
                        new Hobby("篮球_1", "跑步_1", "喝酒_1"),
                        new Hobby("篮球_2", "跑步_2", "喝酒_2"),
                        new Hobby("篮球_3", "跑步_3", "喝酒_3")
                ),
                Lists.newArrayList(
                        new Fancy("街舞", "摄影", "泡妞"),
                        new Fancy("街舞_1", "摄影_1", "泡妞_1"),
                        new Fancy("街舞_2", "摄影_2", "泡妞_2"),
                        new Fancy("街舞_3", "摄影_3", "泡妞_3")
                ),
                new Subject("英语", "语文", "数学")
        ));
        list.add(new Student(200, "小红", 10, 2,
                Lists.newArrayList(
                        new Hobby("篮球", "跑步", "喝酒"),
                        new Hobby("篮球_1", "跑步_1", "喝酒_1"),
                        new Hobby("篮球_2", "跑步_2", "喝酒_2"),
                        new Hobby("篮球_3", "跑步_3", "喝酒_3")
                ),
                Lists.newArrayList(
                        new Fancy("街舞", "摄影", "泡妞"),
                        new Fancy("街舞_1", "摄影_1", "泡妞_1"),
                        new Fancy("街舞_2", "摄影_2", "泡妞_2"),
                        new Fancy("街舞_3", "摄影_3", "泡妞_3")
                ),
                new Subject("英语", "语文", "数学")
        ));
        return list;
    }

    @Data
    private static class Person {
        private Integer pid;
        private String pname;
        private Integer page;
        private String interest;
        private String subject;
    }


    private final static BiConsumer<Person, Student> HOBBY = (person, student) -> {
        Optional.ofNullable(student.getHobbies())
                .flatMap(hobbies -> hobbies.stream().findFirst())
                .ifPresent(hobby -> person.setInterest(hobby.getDrinking()));
        Optional.ofNullable(student.subject).ifPresent(subject -> person.setSubject(subject.getEnglish()));
    };

    private final static BiConsumer<Person, Student> FANCY = (person, student) -> {
        Optional.ofNullable(student.getFancies())
                .flatMap(fancies -> fancies.stream().findFirst())
                .ifPresent(fancy -> person.setInterest(fancy.getDance()));
        Optional.ofNullable(student.subject).ifPresent(subject -> person.setSubject(subject.getMathematics()));
    };

    private final static ImmutableMap<InterestType, BiConsumer<Person, Student>> OF = ImmutableMap.of(
            InterestType.HOBBY, HOBBY,
            InterestType.FANCY, FANCY
    );

    /**
     * BiConsumer<T, U> 实例
     */
    @Test
    public void t() {
        List<Student> studentList = getStudent();
        List<Object> collect = studentList.stream().map(student -> {
            Person person = new Person();
            Optional.ofNullable(student).ifPresent(stu -> {
                person.setPid(stu.getId());
                person.setPname(stu.getName());
                person.setPage(stu.getAge());

                Integer interestType = student.getInterestType();
                InterestType interestTypeByCode = InterestType.getInterestTypeByCode(interestType);
                person.setInterest(interestTypeByCode.message);

                OF.get(interestTypeByCode).accept(person, student);
            });
            return person;
        }).collect(Collectors.toList());

        System.out.println(collect);
    }
}

T reduce(T identity, BinaryOperator<T> accumulator)

java 复制代码 
<!-- commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.9</version>
</dependency>
java 复制代码 
/**
 * @author qfxl
 */
public class LambdaTest {
  @Data
    private static class trip {
        private String departure;
        private String destination;

        private trip(String departure, String destination) {
            this.departure = departure;
            this.destination = destination;
        }
    }

    /**
     * reduce 规则：
     * 例子：1.上海 -> 北京
     *      2.北京 -> 上海
     *      3.天津 -> 西安
     *      4.拉萨 -> 灵芝
     *      5.灵芝 -> 兰州
     *      6.兰州 -> 西宁
     * 展示效果：上海-北京-上海,天津-西安,拉萨-灵芝-兰州-西宁
     */
    private static final BinaryOperator<String> ACCUMULATOR = (v1, v2) -> {
        if (StringUtils.isEmpty(v1)) {
            return v2;
        }
        String[] item = StringUtils.split(v1, ",");
        String[] lastOfItem = StringUtils.split(item[item.length - 1], "-");
        String lastElement = lastOfItem[lastOfItem.length - 1];
        String[] nextItem = StringUtils.split(v2, "-");
        String startElement = nextItem[0];
        if (StringUtils.equals(lastElement, startElement)) {
            return v1 + "-" + nextItem[nextItem.length - 1];
        }
        return v1 + "," + v2;
    };

    @Test
    public void t2() {
        List<trip> list = Lists.newArrayList(
                new trip("上海", "北京"),
                new trip("北京", "上海"),
                new trip("天津", "西安"),
                new trip("拉萨", "灵芝"),
                new trip("灵芝", "兰州"),
                new trip("兰州", "西宁")
        );

        //[上海-北京-上海,天津-西安,拉萨-灵芝-兰州-西宁]
        String reduce = list.stream()
                .map(t -> String.format("%s-%s", t.getDeparture(), t.getDestination()))
                .reduce("", ACCUMULATOR);
        System.out.println(reduce);
    }
}

allMatch(Predicate p)

java 复制代码 
public static final String YYYYMMDD = "yyyyMMdd";
public static final String YYYY_MM_DD = "yyyy-MM-dd";
public static final String YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
public static final String YYYY__MM__DD = "yyyy/MM/dd";
public static final String YYYY__MM__DD_HH_MM = "yyyy/MM/dd HH:mm";
public static final String YYYY__MM__DD_HH_MM_SS = "yyyy/MM/dd HH:mm:ss";

@Test
public void t3() {
    @Data
    class DateValidate {
        private String date;
        private String dateFormat;

        public DateValidate(String date, String dateFormat) {
            this.date = date;
            this.dateFormat = dateFormat;
        }
    }
    List<DateValidate> list = Lists.newArrayList(
            new DateValidate("202086", YYYYMMDD),
            new DateValidate("2020086", YYYYMMDD),
            new DateValidate("2020806", YYYYMMDD),
            new DateValidate("20200806", YYYYMMDD),
            new DateValidate("20200806 19", null),
            new DateValidate("20200806 19:00", null),
            new DateValidate("20200806 19:00:00", null),
            new DateValidate("2020-8-06", YYYY_MM_DD),
            new DateValidate("2020-08-6", YYYY_MM_DD),
            new DateValidate("2020-08-06", YYYY_MM_DD),
            new DateValidate("2020-08-06 19", null),
            new DateValidate("2020-08-06 19:00", YYYY_MM_DD_HH_MM),
            new DateValidate("2020-08-06 19:00:00", YYYY_MM_DD_HH_MM_SS),
            new DateValidate("2020/8/06", YYYY__MM__DD),
            new DateValidate("2020/08/6", YYYY__MM__DD),
            new DateValidate("2020/08/06", YYYY__MM__DD),
            new DateValidate("2020/08/06 19", null),
            new DateValidate("2020/08/06 19:00", YYYY__MM__DD_HH_MM),
            new DateValidate("2020/08/06 19:00:00", YYYY__MM__DD_HH_MM_SS)
    );

    list.forEach(item -> {
        boolean matchDateTime = matchDateTime(item.getDate());
        System.out.println(item.getDate() + " (" + item.getDateFormat() + ")：matchDateTime -> " + matchDateTime);
    });
}

/**
 * 时间校验
 * @param dateTime
 * @return
 */
public static boolean matchDateTime(String dateTime) {
    if (StringUtils.isEmpty(dateTime)) {
        return false;
    }
    String[] dt = dateTime.split("\\s+");
    if (dt.length == 1) {
        return dateMatch(dt[0], "/") || dateMatch(dt[0], "-");
    } else {
        String date = dt[0];
        String time = dt[1];
        return (dateMatch(date, "/") || dateMatch(date, "-")) && timeMatch(time, ":");
    }
}

private static boolean timeMatch(String s, String split) {
    if (StringUtils.isEmpty(s)) {
        return true;
    }

    s = StringUtils.trim(s);
    String[] time = StringUtils.split(s, split);
    boolean isNumber = Arrays.stream(time).anyMatch(StringUtils::isNumeric);
    if (!isNumber) {
        return false;
    }

    if (time.length != 3) {
        return false;
    }

    if (time[0].length() > 2 || Integer.parseInt(time[0]) > 24) {
        return false;
    }


    if (time[1].length() > 2 || Integer.parseInt(time[1]) > 60) {
        return false;
    }

    if (time[2].length() > 2 || Integer.parseInt(time[2]) > 60) {
        return false;
    }

    return true;
}

private static boolean dateMatch(String s, String spl) {
    if (StringUtils.isEmpty(s)) {
        return false;
    }
    s = StringUtils.trim(s);
    String[] date = StringUtils.split(s, spl);
    boolean isNumber = Arrays.stream(date).anyMatch(StringUtils::isNumeric);
    if (!isNumber) {
        return false;
    }

    if (date.length != 3) {
        return false;
    }

    if (date[0].length() != 4) {
        return false;
    }

    if (Integer.parseInt(date[1]) > 12) {
        return false;
    }

    if (Integer.parseInt(date[2]) > 31) {
        return false;
    }

    return true;
}

显示结果

bash 复制代码 
202086 (yyyyMMdd)：matchDateTime -> false
2020086 (yyyyMMdd)：matchDateTime -> false
2020806 (yyyyMMdd)：matchDateTime -> false
20200806 (yyyyMMdd)：matchDateTime -> false
20200806 19 (null)：matchDateTime -> false
20200806 19:00 (null)：matchDateTime -> false
20200806 19:00:00 (null)：matchDateTime -> false
2020-8-06 (yyyy-MM-dd)：matchDateTime -> true
2020-08-6 (yyyy-MM-dd)：matchDateTime -> true
2020-08-06 (yyyy-MM-dd)：matchDateTime -> true
2020-08-06 19 (null)：matchDateTime -> false
2020-08-06 19:00 (yyyy-MM-dd HH:mm)：matchDateTime -> false
2020-08-06 19:00:00 (yyyy-MM-dd HH:mm:ss)：matchDateTime -> true
2020/8/06 (yyyy/MM/dd)：matchDateTime -> true
2020/08/6 (yyyy/MM/dd)：matchDateTime -> true
2020/08/06 (yyyy/MM/dd)：matchDateTime -> true
2020/08/06 19 (null)：matchDateTime -> false
2020/08/06 19:00 (yyyy/MM/dd HH:mm)：matchDateTime -> false
2020/08/06 19:00:00 (yyyy/MM/dd HH:mm:ss)：matchDateTime -> true

groupingBy(Function f)

java 复制代码 
@Test
public void t5() {
    @Data
    class Stu {
        private Integer id;
        private String name;
        private Long money;

        public Stu(Integer id, String name, Long money) {
            this.id = id;
            this.name = name;
            this.money = money;
        }
    }

    List<Stu> list = Lists.newArrayList(
            new Stu(1, "小明", 100L),
            new Stu(1, "小红", 200L),
            new Stu(2, "小黄", 200L),
            new Stu(2, "小紫", 200L)
    );

    Map<Integer, List<Stu>> collect = list.stream().collect(Collectors.groupingBy(Stu::getId));
    System.out.println(JSON.toJSONString(collect, SerializerFeature.PrettyFormat));
}

显示结果

bash 复制代码 
{1:[
		{
			"id":1,
			"money":100,
			"name":"小明"
		},
		{
			"id":1,
			"money":200,
			"name":"小红"
		}
	],2:[
		{
			"id":2,
			"money":200,
			"name":"小黄"
		},
		{
			"id":2,
			"money":200,
			"name":"小紫"
		}
	]
}

flatMap(Function f)

java 复制代码 
@Data
private static class TravelInfo {
    private String trip;
    private String hotelName;
    private List<Order> orders;

    public TravelInfo(String trip, String hotelName, List<Order> orders) {
        this.trip = trip;
        this.hotelName = hotelName;
        this.orders = orders;
    }
}

@Data
private static class Order {
    private Long orderId;
    private List<Travellers> travellers;

    public Order(Long orderId, List<Travellers> travellers) {
        this.orderId = orderId;
        this.travellers = travellers;
    }
}

@Data
private static class Travellers {
    private String userName;
    private String email;

    public Travellers() {
    }

    public Travellers(String userName, String email) {
        this.userName = userName;
        this.email = email;
    }
}

/**
 * flatMap(Function f)：扁平化
 */
@Test
public void t5() {
    TravelInfo travelInfo = new TravelInfo("三人行", "天上人间",
            Lists.newArrayList(
                    new Order(123456789L, Lists.newArrayList(
                            new Travellers("zhangSanFirst", "[email protected]"),
                            new Travellers("zhangSanSecond", "[email protected]")
                    )),
                    new Order(987654321L, Lists.newArrayList(
                            new Travellers("liSiFirst", "[email protected]"),
                            new Travellers("liSiSecond", "[email protected]")
                    )),
                    new Order(987654322L, Lists.newArrayList(
                            new Travellers("wangWu", "[email protected]")
                    )),
                    new Order(987654323L, Lists.newArrayList()),
                    new Order(987654323L, null)
            ));
    System.out.println(JSON.toJSONString(travelInfo, SerializerFeature.PrettyFormat));
    System.out.println();

    List<String> email = travelInfo.getOrders().stream()
            .filter(Objects::nonNull)
            .map(Order::getTravellers)
            .filter(CollectionUtils::isNotEmpty)
            .flatMap(Collection::stream)
            .filter(Objects::nonNull)
            .map(Travellers::getEmail)
            .collect(Collectors.toList());
    System.out.println(email);
}

显示结果

bash 复制代码 
{
	"hotelName":"天上人间",
	"orders":[
		{
			"orderId":123456789,
			"travellers":[
				{
					"email":"[email protected]",
					"userName":"zhangSanFirst"
				},
				{
					"email":"[email protected]",
					"userName":"zhangSanSecond"
				}
			]
		},
		{
			"orderId":987654321,
			"travellers":[
				{
					"email":"[email protected]",
					"userName":"liSiFirst"
				},
				{
					"email":"[email protected]",
					"userName":"liSiSecond"
				}
			]
		},
		{
			"orderId":987654322,
			"travellers":[
				{
					"email":"[email protected]",
					"userName":"wangWu"
				}
			]
		},
		{
			"orderId":987654323,
			"travellers":[]
		},
		{
			"orderId":987654323
		}
	],
	"trip":"三人行"
}

[[email protected], [email protected], [email protected], [email protected], [email protected]]

Optional.ofNullable(T t) 和 T orElse(T other)

java 复制代码 
@Data
private class PaymentDto {
    private Long id;
    private String liqAccountName;
    /**
     * 来款业务：COMPANY-企业来款；OFFLINE-订单线下收款
     */
    private String paymentMode;
    private List<ClaimDto> claimDto;
    private List<OrderClaimDto> orderClaimDto;

    public PaymentDto(Long id, String liqAccountName, String paymentMode, List<ClaimDto> claimDto, List<OrderClaimDto> orderClaimDto) {
        this.id = id;
        this.liqAccountName = liqAccountName;
        this.paymentMode = paymentMode;
        this.claimDto = claimDto;
        this.orderClaimDto = orderClaimDto;
    }
}

@Data
private static class ClaimDto {
    private Long paymentId;
    private String partnerName;
    private Integer amount;

    public ClaimDto(Long paymentId, String partnerName, Integer amount) {
        this.paymentId = paymentId;
        this.partnerName = partnerName;
        this.amount = amount;
    }
}

@Data
private static class OrderClaimDto {
    private Long paymentId;
    private Integer amount;

    public OrderClaimDto(Long paymentId, Integer amount) {
        this.paymentId = paymentId;
        this.amount = amount;
    }
}

@Data
private static class PaymentApiDto {
    private Long id;
    private String liqAccountName;
    private String paymentMode;
    private Long paymentId;
    private String partnerName;
    private Integer amount;
}

private List<PaymentDto> getPaymentDto() {
    List<PaymentDto> list = Lists.newArrayList();
    list.add(new PaymentDto(123456789L, "收款账户_COMPANY", "COMPANY",
            Lists.newArrayList(
                    new ClaimDto(123456789L, "企业名称1", 999),
                    new ClaimDto(123456789L, "企业名称2", 888),
                    new ClaimDto(123456789L, "企业名称3", 777)
            ),
            Lists.newArrayList(
                    new OrderClaimDto(123456789L, 666),
                    new OrderClaimDto(123456789L, 555)
            )));
    list.add(new PaymentDto(987654321L, "收款账户_OFFLINE", "OFFLINE",
            Lists.newArrayList(
                    new ClaimDto(987654321L, "企业名称1", 999),
                    new ClaimDto(987654321L, "企业名称2", 888)
            ),
            Lists.newArrayList(
                    new OrderClaimDto(987654321L, 666),
                    new OrderClaimDto(987654321L, 555)
            )));
    list.add(new PaymentDto(888888888L, "收款账户", null, null, null));
    return list;
}


/**
 * Optional.ofNullable(T t) 和 T orElse(T other)
 */
@Test
public void t6() {
    List<PaymentDto> paymentDtos = getPaymentDto();
    paymentDtos.forEach(System.out::println);
    System.out.println();

    /**
     * 根据 paymentMode 把 claimDto、orderClaimDto 集合数据查分为单条数据
     */
    List<PaymentApiDto> collect = paymentDtos
            .stream()
            .map(paymentDto -> {
                PaymentApiDto apiDto = new PaymentApiDto();
                apiDto.setId(paymentDto.getId());
                apiDto.setLiqAccountName(paymentDto.getLiqAccountName());
                apiDto.setPaymentMode(paymentDto.getPaymentMode());
                ImmutableList<PaymentApiDto> defaultList = ImmutableList.of(apiDto);

                if (StringUtils.equals(paymentDto.getPaymentMode(), "COMPANY")) {
                    return Optional.ofNullable(paymentDto.getClaimDto())
                            .map(claimDtos -> claimDtos.stream()
                                    .map(claimDto -> {
                                        PaymentApiDto paymentApiDto = new PaymentApiDto();
                                        paymentApiDto.setId(paymentDto.getId());
                                        paymentApiDto.setLiqAccountName(paymentDto.getLiqAccountName());
                                        paymentApiDto.setPaymentMode(paymentDto.getPaymentMode());
                                        paymentApiDto.setPaymentId(claimDto.getPaymentId());
                                        paymentApiDto.setPartnerName(claimDto.getPartnerName());
                                        paymentApiDto.setAmount(claimDto.getAmount());
                                        return paymentApiDto;
                                    })
                                    .collect(Collectors.toList())
                            )
                            .orElse(defaultList);
                }
                if (StringUtils.equals(paymentDto.getPaymentMode(), "OFFLINE")) {
                    return Optional.ofNullable(paymentDto.getOrderClaimDto())
                            .map(orderClaimDtos -> orderClaimDtos.stream()
                                    .map(orderClaimDto -> {
                                        PaymentApiDto paymentApiDto = new PaymentApiDto();
                                        paymentApiDto.setId(paymentDto.getId());
                                        paymentApiDto.setLiqAccountName(paymentDto.getLiqAccountName());
                                        paymentApiDto.setPaymentMode(paymentDto.getPaymentMode());
                                        paymentApiDto.setAmount(orderClaimDto.getAmount());
                                        return paymentApiDto;
                                    })
                                    .collect(Collectors.toList())
                            )
                            .orElse(defaultList);
                }
                return defaultList;
            })
            .flatMap(Collection::stream)
            .collect(Collectors.toList());
    collect.forEach(System.out::println);
}

显示结果

bash 复制代码 
LambdaTest.PaymentDto(id=123456789, liqAccountName=收款账户_COMPANY, paymentMode=COMPANY, claimDto=[LambdaTest.ClaimDto(paymentId=123456789, partnerName=企业名称1, amount=999), LambdaTest.ClaimDto(paymentId=123456789, partnerName=企业名称2, amount=888), LambdaTest.ClaimDto(paymentId=123456789, partnerName=企业名称3, amount=777)], orderClaimDto=[LambdaTest.OrderClaimDto(paymentId=123456789, amount=666), LambdaTest.OrderClaimDto(paymentId=123456789, amount=555)])
LambdaTest.PaymentDto(id=987654321, liqAccountName=收款账户_OFFLINE, paymentMode=OFFLINE, claimDto=[LambdaTest.ClaimDto(paymentId=987654321, partnerName=企业名称1, amount=999), LambdaTest.ClaimDto(paymentId=987654321, partnerName=企业名称2, amount=888)], orderClaimDto=[LambdaTest.OrderClaimDto(paymentId=987654321, amount=666), LambdaTest.OrderClaimDto(paymentId=987654321, amount=555)])
LambdaTest.PaymentDto(id=888888888, liqAccountName=收款账户, paymentMode=null, claimDto=null, orderClaimDto=null)

LambdaTest.PaymentApiDto(id=123456789, liqAccountName=收款账户_COMPANY, paymentMode=COMPANY, paymentId=123456789, partnerName=企业名称1, amount=999)
LambdaTest.PaymentApiDto(id=123456789, liqAccountName=收款账户_COMPANY, paymentMode=COMPANY, paymentId=123456789, partnerName=企业名称2, amount=888)
LambdaTest.PaymentApiDto(id=123456789, liqAccountName=收款账户_COMPANY, paymentMode=COMPANY, paymentId=123456789, partnerName=企业名称3, amount=777)
LambdaTest.PaymentApiDto(id=987654321, liqAccountName=收款账户_OFFLINE, paymentMode=OFFLINE, paymentId=null, partnerName=null, amount=666)
LambdaTest.PaymentApiDto(id=987654321, liqAccountName=收款账户_OFFLINE, paymentMode=OFFLINE, paymentId=null, partnerName=null, amount=555)
LambdaTest.PaymentApiDto(id=888888888, liqAccountName=收款账户, paymentMode=null, paymentId=null, partnerName=null, amount=null)
相关推荐
风铃儿~1 分钟前
Spring AI 入门：Java 开发者的生成式 AI 实践之路
java·人工智能·spring
斯普信专业组7 分钟前
Tomcat全方位监控实施方案指南
java·tomcat
忆雾屿17 分钟前
云原生时代 Kafka 深度实践：06原理剖析与源码解读
java·后端·云原生·kafka
武昌库里写JAVA30 分钟前
iview Switch Tabs TabPane 使用提示Maximum call stack size exceeded堆栈溢出
java·开发语言·spring boot·学习·课程设计
gaoliheng00639 分钟前
Redis看门狗机制
java·数据库·redis
我是唐青枫41 分钟前
.NET AOT 详解
java·服务器·.net
Su米苏1 小时前
Axios请求超时重发机制
java
本郡主是喵2 小时前
并发编程 - go版
java·服务器·开发语言
南风lof2 小时前
源码赏析：Java线程池中的那些细节
java·源码阅读
热门推荐
01基于STM32的智能电池管理系统02KGG转MP3工具|非KGM文件|解密音频03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04【无人机】无人机通信模块，无人机图数传模块的介绍，数传，图传，图传数传一体电台，05从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑06【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！07VMware虚拟机安装Win7专业版保姆级教程（附镜像包）08DeepSeek各版本说明与优缺点分析09组基轨迹建模 GBTM的介绍与实现（Stata 或 R）10海康Visionmaster-常见问题排查方法-启动阶段