java8用法

我会带着你远行 2022-05-28 01:47 115阅读 0赞

import org.junit.Test;
    
    import java.time.DayOfWeek;
    import java.time.LocalDateTime;
    import java.time.temporal.TemporalAdjusters;
    import java.util.*;
    import java.util.function.BiPredicate;
    import java.util.function.Consumer;
    import java.util.stream.Collectors;
    import java.util.stream.LongStream;
    import java.util.stream.Stream;
    
    /** * @program: * @description: * @author: lvzhensong * @create: 2018-03-27 11:37 **/ public class Java8 {
    
        List<Person> persons = Arrays.asList(
                new Person(2, "钱四", 24),
                new Person(1, "张三", 33),
                new Person(2, "李四", 24),
                new Person(3, "王五", 65),
                new Person(4, "赵六", 26),
                new Person(4, "赵六", 26),
                new Person(5, "陈七", 27)
        );
    
        @Test
        public void test1(){
            Runnable runnable = () -> System.out.println("xxxx");
            runnable.run();
    
            Consumer con = (str) -> System.out.println(str);
            con.accept("123");
            Consumer con1 = str -> System.out.println(str);
            con.accept("456");
    
            Comparator<Integer> com = (x,y) -> {
                return Integer.compare(x,y);
            };
            // 当 Lambda 体只有一条语句时，return 与大括号可以省略
            Comparator<Integer> com2 = (x,y) -> Integer.compare(x,y);
    
            //四大函数型接口  供给型  消费型   函数型  断言型
            /*使用注意事项:
            * 1.Lambda 体中调用方法的参数列表与返回值类型,要与函数式接口中抽象方法的函数列表和返回值类型保持一致。
            * 2.若Lambda 参数列表中第一个参数是实例方法调用者,第二个参数是实例方法的参数 可以使用 ClassName :: method*/
    
    
            Comparator<Integer> com3 = (x,y) -> Integer.compare(x, y);
            //使用前提,compare的参数和返回值与Comparator一致
            Comparator<Integer> comparator = Integer :: compare;
    
            BiPredicate<String, String> bp = (x,y) -> x.equals(y);
            //使用条件:第一个参数是实例方法调用者,第二个参数是实例方法的参数
            BiPredicate<String, String> biPredicate = String :: equals;
    
            //Stream流
    
    
        }
    
        @Test
        public void test2(){
            Stream<Person> stream = persons.stream().filter(e -> e.getAge()>25);
            stream.forEach(System.out::println);
    
            List<String> list = Arrays.asList("a","bb","c","d","e");
            list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
    
            persons.stream().map(Person::getName).forEach(System.out::println);
            persons.stream().map(e -> e.getName()).forEach(System.out::println);
    
    
            Stream<Stream<Character>> stream1 = list.stream().map(Java8::filterCharacter);
            stream1.forEach(s -> s.forEach(System.out::println));
    
            Stream<Character> stream2 = list.stream().flatMap(Java8::filterCharacter);
            stream2.forEach(System.out::println);
        }
    
        //处理字符串
        public static Stream<Character> filterCharacter(String str){
            List<Character> list = new ArrayList<>();
    
            for (Character character : str.toCharArray()) {
                list.add(character);
            }
            return list.stream();
        }
    
    
        List<Person> persons2 = Arrays.asList(
                new Person(2, "钱四", 24,Status.YOUNG),
                new Person(1, "张三", 23,Status.YOUNG),
                new Person(2, "李四", 24,Status.YOUNG),
                new Person(3, "王五", 65,Status.OLD),
                new Person(4, "赵六", 26,Status.MIDDLE),
                new Person(4, "赵六", 56,Status.OLD),
                new Person(5, "陈七", 27,Status.MIDDLE)
        );
    
        //  查找与匹配   规约reduce与收集collect
        @Test
        public void test3(){
            boolean b = persons2.stream().allMatch(e -> e.getStatus().equals(Status.OLD));
    
            Optional<Person> op = persons2.stream().sorted((e1, e2) -> Integer.compare(e1.getAge(),e2.getAge())).findFirst();
            //返回流中最大值
            Optional<Person> optional = persons2.stream()
                    .max((e1,e2) -> Integer.compare(e1.getId(), e2.getId()));
    
    
    
            Optional<Integer> op2 = persons2.stream().map(Person::getAge).max(Integer::compare);
    
        }
    
        @Test
        public void test4(){
            List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8);
            Integer sum = list.stream().reduce(0,(x,y)-> x+y);
    
            Optional<Integer> optional = list.stream().reduce(Integer::sum);
        }
    
    
        @Test
        public void test5(){
            Long count = persons.stream().collect(Collectors.counting());
    
            Double avg = persons.stream().collect(Collectors.averagingInt(Person::getAge));
    
            Integer sum = persons.stream().collect(Collectors.summingInt(Person::getAge));
    
            Optional<Person> op = persons.stream().collect(Collectors.maxBy((e1,e2)->Integer.compare(e1.getAge(),e2.getAge())));
        }
    
        @Test
        public void test6(){
            //分组
            Map<Status,List<Person>> map = persons2.stream().collect(Collectors.groupingBy(Person::getStatus));
    
            //多级分组
            Map<Status, Map<String, List<Person>>> map2 = persons2.stream().collect(Collectors.groupingBy(Person::getStatus,Collectors.groupingBy(e -> {
                if (e.getId()%2 == 1) {
                    return "单号";
                } else {
                    return "双号";
                }
            })));
            System.out.println(map2);
        }
    
        @Test
        public void test7(){
            LocalDateTime ldt = LocalDateTime.now();
            System.out.println(ldt);
            LocalDateTime ldt2 = ldt.withDayOfMonth(8);
            System.out.println(ldt2);
    
            LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
            System.out.println(ldt3);
    
    
        }
    
    }