java8 Lambda表达式

package lambda;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

/**
 * @author Endless
 * Lamdbda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法 (jdk8中 default修饰的方法有默认的实现)
 * 语法形式 () -> {} ,()描述参数列表 {}描述方法体  -> 为运算符(goes to)
 * 我们不是必须要自己重写某个匿名内部类的方法，我们可以可以利用 lambda表达式的接口快速指向一个已经被实现的方法
 */
public class Main {
    public static void main(String[] args) {
        // 1.无参无返回
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println("NoReturnNoParam");
        };
        noReturnNoParam.method();

        // 2.一个参数无返回
        NoReturnOneParam noReturnOneParam = (int a) -> {
            System.out.println("NoReturnOneParam param:" + a);
        };
        noReturnOneParam.method(6);

        // 3.多个参数无返回
        NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
            System.out.println("NoReturnMultiParam param:" + "{" + a + "," + b + "}");
        };
        noReturnMultiParam.method(6, 8);

        // 4.无参有返回值
        ReturnNoParam returnNoParam = () -> {
            System.out.print("ReturnNoParam");
            return 1;
        };
        int res = returnNoParam.method();
        System.out.println("return:" + res);

        // 5.一个参数有返回值
        ReturnOneParam returnOneParam = (int a) -> {
            System.out.println("ReturnOneParam param:" + a);
            return 1;
        };
        int res2 = returnOneParam.method(6);
        System.out.println("return:" + res2);

        // 6.多个参数有返回值
        ReturnMultiParam returnMultiParam = (int a, int b) -> {
            System.out.println("ReturnMultiParam param:" + "{" + a + "," + b + "}");
            return 1;
        };
        int res3 = returnMultiParam.method(6, 8);
        System.out.println("return:" + res3);


        // lambda表达式引用方法
        // 方法归属者::方法名  静态方法的归属者为类名，普通方法归属者为对象
        ReturnOneParam lambda1 = a -> doubleNum(a);
        System.out.println(lambda1.method(3));

        //引用了已经实现的doubleNum方法 (静态方法)
        ReturnOneParam lambda2 = Main::doubleNum;
        System.out.println(lambda2.method(3));

        // 引用了已经实现的addTwo方法 (成员方法)
        Main main = new Main();
        ReturnOneParam lambda3 = main::addTwo;
        System.out.println(lambda3.method(3));

        // 构造方法的引用
        ItemCreatorBlankConstruct creator1 = () -> new Item();
        Item item1 = creator1.getItem();
        ItemCreatorBlankConstruct creator2 = Item::new;
        Item item2 = creator2.getItem();
        ItemCreatorParamConstruct creator3 = Item::new;
        Item item3 = creator3.getItem(1, "鼠标", 199);

        // lambda表达式创建线程
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":\t" + i);
            }
        });
        t.start();

        // 遍历集合
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5);
        list.forEach(System.out::println);
        list.forEach(item -> {
            if (item % 2 == 0) {
                System.out.println(item);
            }
        });

        // 删除元素
        list.removeIf(item -> item % 2 == 0);
        list.forEach(System.out::println);

        // 集合内元素排序
        list.sort((o1, o2) -> o1 - o2);
        list.forEach(System.out::println);

        // lambda表达式中的闭包问题
        // 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
        int num = 10;
        Consumer<String> consumer = item -> {
            System.out.println(num);
        };
        // num = num + 2; 不可以赋值，虽然num没有用final修饰，但是编译期间虚拟机会加上final修饰关键词
        consumer.accept("hello");
    }

    /**
     * 要求
     * 1.参数数量和类型要与接口中定义的一致
     * 2.返回值类型要与接口中定义的一致
     */
    public static int doubleNum(int a) {
        return a * 2;
    }

    public int addTwo(int a) {
        return a + 2;
    }


}


/**
 * 多参数无返回
 */
@FunctionalInterface
interface NoReturnMultiParam {
    // 一个需要被实现的方法
    void method(int a, int b);

    // default方法有默认的实现
    default void defaultMethod() {
    }
}

/**
 * 无参无返回值
 */
@FunctionalInterface
interface NoReturnNoParam {
    void method();
}

/**
 * 一个参数无返回
 */
@FunctionalInterface
interface NoReturnOneParam {
    void method(int a);
}

/**
 * 多个参数有返回值
 */
@FunctionalInterface
interface ReturnMultiParam {
    int method(int a, int b);
}

/**
 * 无参有返回
 */
@FunctionalInterface
interface ReturnNoParam {
    int method();
}

/**
 * 一个参数有返回值
 */
@FunctionalInterface
interface ReturnOneParam {
    int method(int a);
}

interface ItemCreatorBlankConstruct {
    Item getItem();
}

interface ItemCreatorParamConstruct {
    Item getItem(int id, String name, double price);
}

@Data
@NoArgsConstructor
@AllArgsConstructor
class Item {
    private int id;
    private String name;
    private double price;
}