Runnable r = () -> System.out.println("Lambda");

Consumer<String> consumer = (x) -> System.out.println(x);

Consumer<String> consumer = x -> System.out.println(x);

Comparator<Integer> comparator = (x, y) -> {
    System.out.println("Lambda");
    return Integer.compare(x, y);
};

Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);

// 下面代码效果相同
Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
Comparator<Integer> comparator = (Integer x, Integer y) -> Integer.compare(x, y);

@FunctionalInterface
public interface FunctionInterface<T> {
    T get(T t);
    
    default void value() {
        // do somethings
    }
}

public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        list = filter(list, ls -> {
            List<Integer> tp = new ArrayList<>();
            for (Integer l : ls) {
                if (l < 3 || l > 6) {
                    tp.add(l);
                }
            }
            return tp;
        });
        System.out.println(list);
    }

    public static List<Integer> filter(List<Integer> list, FunctionInterface<List<Integer>> func) {
        return func.get(list);
    }
}

public class Test {
    public static void main(String[] args) {
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("huang");
    }
}

public class Test {
    public static void main(String[] args) {
        Supplier<Long> supplier = () -> System.currentTimeMillis();
        Long timestamp = supplier.get();
        System.out.println(timestamp);
    }
}

public class Test {
    public static void main(String[] args) {
        Function<String, Integer> function = s -> Integer.valueOf(s);
        Integer apply = function.apply("9527");
        System.out.println(apply);
    }
}

public class Test {
    public static void main(String[] args) {
        Predicate<Object> predicate = object -> object instanceof Test;
        boolean test = predicate.test(new Test());
        System.out.println(test);
    }
}

/*
 * 方法引用
 */
public class Test {
    public static void main(String[] args) {

        /*
         * 类::实例方法
         */
        Consumer<String> consumer1 = s -> System.out.println(s);
        Consumer<String> consumer2 = System.out::println;

        /*
         * 类::静态方法
         */
        Supplier<Long> supplier1 = () -> System.currentTimeMillis();
        Supplier<Long> supplier2 = System::currentTimeMillis;

        /*
         * 对象::实例方法
         */
        Random random = new Random();
        Function<Integer, Integer> function1 = bound -> random.nextInt(bound);
        Function<Integer, Integer> function2 = random::nextInt;
    }
}

/*
 * 构造器引用
 */
public class Test {
    public static void main(String[] args) {
        Function<String, String> function1 = s -> new String(s);
        Function<String, String> function2 = String::new;

        Function<Integer, String[]> function3 = size -> new String[size];
        Function<Integer, String[]> function4 = String[]::new;
    }
}

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
Stream<Integer> stream = list.stream();
Stream<Integer> parallelStream = list.parallelStream();

int[] arr1 = new int[10];
IntStream stream1 = Arrays.stream(arr1);

long[] arr2 = new long[10];
LongStream stream2 = Arrays.stream(arr2);

double[] arr3 = new double[10];
DoubleStream stream3 = Arrays.stream(arr3);

Object[] arr4 = new Object[10];
Stream<Object> stream4 = Arrays.stream(arr4);

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9);

// 迭代 有序流
Stream<Integer> stream1 = Stream.iterate(0, x -> x + 1); // 无限流
Stream<Integer> stream2 = Stream.iterate(0, p -> p < 10, x -> x + 1); // 有限流

// 生成 无序流
Random random = new Random();
Stream<Integer> stream = Stream.generate(random::nextInt);

Stream.Builder<Integer> builder = Stream.builder();
builder.accept(1); // 向正在构建的流添加一个元素
builder.accept(2);
builder.accept(3);
builder.accept(4);
Stream<Integer> build = builder.build(); // 构建流，将此构建器转换为构建状态

/*
 * 中间操作：筛选与切片
 */
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,4,6);

        // filter 操作：value > 3 的元素保留，流中元素：{4,5,6,7,8,9,4,6}
        Stream<Integer> filter = list.stream().filter(i -> i > 3);

        // distinct 操作：重复元素仅保留一个，流中元素：{4,5,6,7,8,9}
        Stream<Integer> distinct = filter.distinct();

        // limit 操作：流中的前 3 个元素保留，流中元素：{4,5,6}
        Stream<Integer> limit = distinct.limit(3);

        // skip 操作：跳过流的前 1 个元素，流中元素：{5,6}
        Stream<Integer> skip = limit.skip(1);
    }
}

/*
 * 中间操作：映射
 */
public class Test {
    public static void main(String[] args) {
        List<Double> list = Arrays.asList(1.11,2.22,3.33,4.44,5.55,6.66,7.77,8.88,9.99);

        // {...}
        Stream<Double> map = list.stream().map(i -> i * i);

        // {1,2,3,4,5,6,7,8,9}
        IntStream mapToInt = list.stream().mapToInt(Double::intValue);

        // {2.11,3.22,4.33,5.44,6.55,7.66,8.77,9.88,10.99}
        DoubleStream mapToDouble = list.stream().mapToDouble(i -> i + 1);

        // {1,2,3,4,6,7,8,9,10}
        LongStream mapToLong = list.stream().mapToLong(Math::round);

        // {1,11,2,22,3,33,4,44,5,55,6,66,7,77,8,88,9,99}
        Stream<String> flatmap = list.stream().flatMap(i -> Arrays.stream(i.toString().split("\\.")));
    }
}

/*
 * 中间操作：排序
 */
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(23,345,1,56,78,231,-2,7,123);

        // -2, 1, 7, 23, 56, 78, 123, 231, 345
        Stream<Integer> sorted = list.stream().sorted();

        // 345, 231, 123, 78, 56, 23, 7, 1, -2,
        list.stream().sorted((x, y) -> -(x - y)).forEach(System.out::println);
    }
}

/*
 * 终止操作：查找与匹配
 */
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);

        // false
        boolean allMatch = list.stream().allMatch(i -> i > 5);

        // true
        boolean anyMatch = list.stream().anyMatch(i -> i > 5);

        // false
        boolean noneMatch = list.stream().noneMatch(i -> i > 5);

        // Optional 封装， first.get() 取得元素值 ：1
        Optional<Integer> first = list.stream().findFirst();

        // 串行：第一个元素； 并行：任意一个
        Optional<Integer> any = list.stream().findAny();

        // 9
        long count = list.stream().count();

        // 9
        Optional<Integer> max = list.stream().max((x, y) -> x - y);

        // 1
        Optional<Integer> min = list.stream().min((x, y) -> x - y);
    }
}

/*
 * 终止操作：规约
 */
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);

        // 45
        Integer reduce1 = list.stream().reduce(0, Integer::sum);

        // 45
        Optional<Integer> reduce2 = list.stream().reduce(Integer::sum);
    }
}

public class Employee {

    private int id;
    private String name;
    private int age;
    private double salary;
    private Status status;

    public Employee() {
    }

    public Employee(String name) {
        this.name = name;
    }

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public Employee(int id, String name, int age, double salary, Status status) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.status = status;
    }

    public Status getStatus() {
        return status;
    }

    public void setStatus(Status status) {
        this.status = status;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String show() {
        return "测试方法引用！";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        long temp;
        temp = Double.doubleToLongBits(salary);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        if (age != other.age)
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
                + "]";
    }

    public enum Status {
        FREE, BUSY, VOCATION;
    }
}

/**
 * 终止操作：收集
 */
public class StreamTest {
    List<Employee> emps = Arrays.asList(
            new Employee(102, "李四", 79, 6666.66, Employee.Status.BUSY),
            new Employee(101, "张三", 18, 9999.99, Employee.Status.FREE),
            new Employee(103, "王五", 28, 3333.33, Employee.Status.VOCATION),
            new Employee(104, "赵六", 8, 7777.77, Employee.Status.BUSY),
            new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee(105, "田七", 38, 5555.55, Employee.Status.BUSY)
    );

    // collect：将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
    @Test
    public void test1(){
        List<String> list = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());
        System.out.println(list);

        Set<String> set = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toSet());
        System.out.println(set);

        Set<String> hs = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        System.out.println(hs);
    }

    @Test
    public void test2(){
        // 最大值
        Optional<Double> max = emps.stream()
                .map(Employee::getSalary)
                .collect(Collectors.maxBy(Double::compare));
        System.out.println(max.get());

        // 最小值
        Optional<Employee> op = emps.stream()
                .collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        System.out.println(op.get());

        // 总值
        Double sum = emps.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(sum);

        // 平均值
        Double avg = emps.stream()
                .collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);

        // 总数
        Long count = emps.stream()
                .collect(Collectors.counting());
        System.out.println(count);

        // 结果值的汇总统计信息
        DoubleSummaryStatistics dss = emps.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(dss.getMax());
    }

    // 分组
    @Test
    public void test3(){
        Map<Employee.Status, List<Employee>> map = emps.stream()
                .collect(Collectors.groupingBy(Employee::getStatus));
        System.out.println(map);
    }

    // 多级分组
    @Test
    public void test4(){
        Map<Employee.Status, Map<String, List<Employee>>> map = emps.stream()
                .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy(e -> {
                    if(e.getAge() >= 60)
                        return "老年";
                    else if(e.getAge() >= 35)
                        return "中年";
                    else
                        return "成年";
                })));
        System.out.println(map);
    }

    // 分区
    @Test
    public void test5(){
        Map<Boolean, List<Employee>> map = emps.stream()
                .collect(Collectors.partitioningBy(e -> e.getSalary() >= 5000));
        System.out.println(map);
    }

    // 将流元素连接成格式字符串
    @Test
    public void test6(){
        String str = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.joining("," , "-", "-"));
        System.out.println(str);
    }

    @Test
    public void test7(){
        Optional<Double> sum = emps.stream()
                .map(Employee::getSalary)
                .collect(Collectors.reducing(Double::sum));
        System.out.println(sum.get());
    }
}

long sum = LongStream.rangeClosed(0, 10000000000L)
                .parallel() // 返回并行的等效流
                .sum();

getYear()                         int        获取当前日期的年份
getMonth()                        Month      获取当前日期的月份对象
getMonthValue()                   int        获取当前日期是第几月
getDayOfWeek()                    DayOfWeek  表示该对象表示的日期是星期几
getDayOfMonth()                   int        表示该对象表示的日期是这个月第几天
getDayOfYear()                    int        表示该对象表示的日期是今年第几天
withYear(int year)                LocalDate  修改当前对象的年份
withMonth(int month)              LocalDate  修改当前对象的月份
withDayOfMonth(intdayOfMonth)     LocalDate  修改当前对象在当月的日期
isLeapYear()                      boolean    是否是闰年
lengthOfMonth()                   int        这个月有多少天
lengthOfYear()                    int        该对象表示的年份有多少天（365或者366）
plusYears(longyearsToAdd)         LocalDate  当前对象增加指定的年份数
plusMonths(longmonthsToAdd)       LocalDate  当前对象增加指定的月份数
plusWeeks(longweeksToAdd)         LocalDate  当前对象增加指定的周数
plusDays(longdaysToAdd)           LocalDate  当前对象增加指定的天数
minusYears(longyearsToSubtract)   LocalDate  当前对象减去指定的年数
minusMonths(longmonthsToSubtract) LocalDate  当前对象减去注定的月数
minusWeeks(longweeksToSubtract)   LocalDate  当前对象减去指定的周数
minusDays(longdaysToSubtract)     LocalDate  当前对象减去指定的天数
compareTo(ChronoLocalDateother)   int        比较当前对象和other对象在时间上的大小，返回值如果
    为正，则当前对象时间较晚，
isBefore(ChronoLocalDateother)    boolean    比较当前对象日期是否在other对象日期之前
isAfter(ChronoLocalDateother)     boolean    比较当前对象日期是否在other对象日期之后
isEqual(ChronoLocalDateother)     boolean    比较两个日期对象是否相等

/**
 * 1. LocalDate、LocalTime、LocalDateTime
 */
public void test1(){
    LocalDateTime ldt = LocalDateTime.now();
    System.out.println(ldt);

    LocalDateTime ld2 = LocalDateTime.of(2021, 11, 4, 20, 40, 10);
    System.out.println(ld2);

    LocalDateTime ldt3 = ld2.plusYears(20);
    System.out.println(ldt3);

    LocalDateTime ldt4 = ld2.minusMonths(2);
    System.out.println(ldt4);

    System.out.println(ldt.getYear());
    System.out.println(ldt.getMonthValue());
    System.out.println(ldt.getDayOfMonth());
    System.out.println(ldt.getHour());
    System.out.println(ldt.getMinute());
    System.out.println(ldt.getSecond());
}

/**
 * 2. Instant : 时间戳。（使用 Unix 元年  1970年1月1日 00:00:00 所经历的毫秒值
 */
public void test2(){
    Instant ins = Instant.now();  // 默认使用 UTC 时区
    System.out.println(ins);

    OffsetDateTime odt = ins.atOffset(ZoneOffset.ofHours(8));
    System.out.println(odt);

    System.out.println(ins.getNano());

    Instant ins2 = Instant.ofEpochSecond(5);
    System.out.println(ins2);
}

/**
 * 3. Duration : 用于计算两个 时间 间隔
 *    Period : 用于计算两个 日期 间隔
 */
public void test3(){
    Instant ins1 = Instant.now();

    try {
        Thread.sleep(1000);
    } catch (InterruptedException ignored) {
        //
    }

    Instant ins2 = Instant.now();
    System.out.println("耗费时间：" + Duration.between(ins1, ins2).toMillis());

    LocalDate ld1 = LocalDate.now();
    LocalDate ld2 = LocalDate.of(2019, 1, 1);

    Period pe = Period.between(ld2, ld1);
    System.out.println(pe.getYears());
    System.out.println(pe.getMonths());
    System.out.println(pe.getDays());
}

/**
 * 4. TemporalAdjuster : 时间校正器
 */
public void test4(){
    LocalDateTime ldt = LocalDateTime.now();
    System.out.println(ldt);

    LocalDateTime ldt2 = ldt.withDayOfMonth(10);
    System.out.println(ldt2);

    LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
    System.out.println(ldt3);

    // 自定义：下一个工作日
    LocalDateTime ldt5 = ldt.with(l -> {
        LocalDateTime ldt4 = (LocalDateTime) l;

        DayOfWeek dow = ldt4.getDayOfWeek();

        if(dow.equals(DayOfWeek.FRIDAY)){
            return ldt4.plusDays(3);
        } else if(dow.equals(DayOfWeek.SATURDAY)){
            return ldt4.plusDays(2);
        } else {
            return ldt4.plusDays(1);
        }
    });
    System.out.println(ldt5);
}

/**
 * 5. DateTimeFormatter : 解析和格式化日期或时间
 */
public void test5(){
    DateTimeFormatter dtf1 = DateTimeFormatter.ISO_LOCAL_DATE;
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");

    LocalDateTime ldt = LocalDateTime.now();
    String strDate = ldt.format(dtf);

    System.out.println(strDate);

    LocalDateTime newLdt = ldt.parse(strDate, dtf);
    System.out.println(newLdt);
}

/**
 * 6.ZonedDate、ZonedTime、ZonedDateTime ：带时区的时间或日期
 */
public void test7(){
    LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
    System.out.println(ldt);

    ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("US/Pacific"));
    System.out.println(zdt);
}

public interface MyInterface {
    default void smile() {
        System.out.println("smile");
    }
}

public interface MyInterface {
    
    default void smile() {
        System.out.println("smile");
    }

    public static void cry() {
        System.out.println("cry");
    }
}

/**
 * Optional 操作
 */
public class OptionalTest {
    public static void main(String[] args) {
        // Optional<T> of(T value)  传入 null 发生 NullPointerException
        Optional<String> optional1 = Optional.of(new String("huang"));

        // 调用 optional2.get() 发生 NullPointerException
        Optional<Object> optional2 = Optional.empty();

        Optional<Object> optional3 = Optional.ofNullable(null);

        optional1.ifPresent(System.out::println);

        Object orElse = optional3.orElse(1);
        System.out.println(orElse);

        Object orElseGet = optional3.orElseGet(() -> new String("huang"));
        System.out.println(orElseGet);

        Optional<Integer> map = optional3.map(Object::hashCode);
        System.out.println(map);

        Optional<Object> flatMap = optional3.flatMap(m -> Optional.empty());
        System.out.println(flatMap);
    }
}

@Repeatable(value = MyAnnotations.class) // MyAnnotations ： 该重复注解的容器注解
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE})
public @interface MyAnnotation {
    String value() default "dahuang";
}

@Retention(RetentionPolicy.RUNTIME)
@Target(value={TYPE})
public @interface MyAnnotations { // 用于装重复注解的容器
    MyAnnotation[] value();
}

/**
 *  测试
 * @author dahuang
 * @date 2021/11/4 21:59
 */
@MyAnnotation(value = "小碗")
@MyAnnotation(value = "小李")
public class AnnotationTest {
    public static void main(String[] args) {
        Class<AnnotationTest> testClass = AnnotationTest.class;
        MyAnnotation[] annotations = testClass.getAnnotationsByType(MyAnnotation.class);
        for (MyAnnotation annotation : annotations) {
            System.out.println(annotation.value());
        }
    }
}

// 结果： 👇
小碗
小李