java8用法

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);


    }

}