@Data
public class Persion {
    private String name;
    private Integer age;
    private String phonenum;
}

package com.zanglikun.Java8新特性;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;

public class lambda表达式 {

    private static ArrayList<Integer> list = new ArrayList();

    /**
     * 参考网站 https://www.cnblogs.com/haixiang/p/11029639.html
     *
     * Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。
     *
     * JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。
     *
     * Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法
     * jdk 8 中有另一个新特性：default， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。
     *
     * @FunctionalInterface注解
     * 修饰函数式接口的，要求接口中的抽象方法(没有方法体)只有一个。与形参列表、返回值无关。 这个注解往往会和 lambda 表达式一起出现。
     *
     *
     * Lambda 基础语法#
     * Predicate  评估参数表达式
     * Consumer：代表了接受一个输入参数并且无返回的操作，相当于消费者。
     * 格式   语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。
     *  ()括号里面参数名 不能与该方法内的参数同名
     *  当方法只有一个参数，可以省略（）
     *  参数类型可省略、但是必须都省略
     *  可以省略{}，但是必须要求只有一条代码语句
     *  如果方法体中只有一条语句，并且是return语句的时候，可以省略方法体大括号
     *

     */
    @Test
    public void 遍历并输出集合(){
        //往list集合中添加元素
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
        list.forEach(System.out::println);

        System.out.println("第二种写法");
    
        
        list.forEach(element -> {
            System.out.print(element+",");
        });
    }



    @Test
    public void 删除集合元素(){
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);

        System.out.println("操作前");
        list.forEach(System.out::print);

        System.out.println("操作后");
        list.removeIf( arg -> arg%2 ==0 );
        list.forEach(System.out::println);
    }

    @Test
    public void 排序集合元素(){
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
        System.out.println("操作前");
        list.forEach(System.out::print);

        System.out.println("降序

操作后");
        list.sort(((o1, o2) -> o2 - o1));
        list.forEach(System.out::print);
    }



    //Lambda 表达式中的闭包问题：代码在编译期间虚拟机会把该变量加上Final修饰，就无法修改了
    @Test
    public void Lambda表达式中的闭包问题(){
        int num = 0;
        Consumer consumer = element -> {
            System.out.println(num);
        };
        //num = num + 1;
        consumer.accept(1);
        System.out.println(num);
    }






    // 利用lambda表达式的接口快速指向一个已经被实现的方法
    // 方法归属者::方法名 静态方法的归属者为类名，普通方法归属者为对象
    @Test
    public void 利用lambda表达式的接口快速指向一个已经被实现的方法(){
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
        //list.forEach(System.out::println);    //这里System.out::print 就是
        list.forEach(lambda表达式::静态方法);    //这里System.out::print 就是
        
        //创建对象
        lambda表达式 lamb = new lambda表达式();
        list.forEach(lamb::非静态方法);

    }
    
    // 为什么这个方法一定要有参数，因为list.forEach实际上是拿到List的每一个元素，传入目标方法，所以一定要加参数！
    private static void 静态方法(Object obj) {
        System.out.println("静态方法已经执行了...");
    }

    // 为什么这个方法一定要有参数，因为list.forEach实际上是拿到List的每一个元素，传入目标方法，所以一定要加参数！
    private void 非静态方法(Object obj) {
        System.out.println("非静态方法已经执行了...");
    }




    @Test
    public void Lambda表达式中的闭包问题(){
        int num = 0;
        Consumer consumer = element -> {
            System.out.println(num);
        };
        /* 不放开注释会报错
        num = num + 1; */
        consumer.accept(1);
        System.out.println(num);
    }
    
}

    @Test
    public void 遍历Map集合(){
        HashMap<String,String> hashMap = new HashMap<>();
        hashMap.put("姓名","张三");
        hashMap.put("年龄","20");
        hashMap.forEach((k,v) -> {
            System.out.print(k + " : ");
            System.out.println(v);
        });
    }