Lambda 表达式练习

目录

sorted() 四种排序

List 转 Map

map 映射

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

BiConsumer,>

T reduce(T identity, BinaryOperator accumulator)

allMatch(Predicate p)

groupingBy(Function f)

flatMap(Function f)

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

先来写个基本类

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 getStudents() {
        List 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() 四种排序

@Test
public void sortedTest() {
    List students = this.getStudents();
    //正序：常规写法
    List 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 collectComparator = students.stream().sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());
    collectComparator.forEach(System.out::println);
    System.out.println();
 
    //倒序：常规写法
    List 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 collectComparatorReversed = students.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
    collectComparatorReversed.forEach(System.out::println);
}

List 转 Map

@Test
public void listToMapTest() {
    List students = this.getStudents();
    Map 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 映射

 @Test
    public void mapTest() {
        List students = this.getStudents();
//        List 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

public static  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

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.12version>
dependency>
        
<dependency>
    <groupId>com.google.guavagroupId>
    <artifactId>guavaartifactId>
    <version>28.2-jreversion>
dependency>

/**
 * @author vincent
 */
public class LambdaTest {
    @Data
    private static class Student {
        private Integer id;
        private String name;
        private Integer age;
        private Integer interestType;
        private List hobbies;
        private List fancies;
        private Subject subject;
 
        private Student(Integer id, String name, Integer age, Integer interestType, List hobbies, List 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 getStudent() {
        List 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 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 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> OF = ImmutableMap.of(
            InterestType.HOBBY, HOBBY,
            InterestType.FANCY, FANCY
    );
 
    /**
     * BiConsumer 实例
     */
    @Test
    public void t() {
        List studentList = getStudent();
        List