Lambda相关图形

序言

1. 概述：
   1. Lambda是JDK8语法糖中函数式编程思想，让我们不用关注是什么对象，而关注的是对数据进行了什么操作【三更草堂】。
   2. Lambda可以对某些匿名内部类的写法进行简化。

2. 基本格式【boge】：

   (参数类型 参数名称) -> {
         代码体;
   }

   格式说明：

         (参数类型 参数名称)：参数列表

         {代码体;}：方法体

         ->：箭头，分割参数列表和方法体
3. 省略规则 【三更草堂】 ：

   * 小括号内的参数类型可以省略。
   * 如果方法只有一个参数，则小括号可以省略。
   * 如果方法体有且仅有一句代码，则可以同时省略大括号、return关键字、唯一一句代码的语句分号。
   * 以上这些规则都记不住也可以省略不记。

4. Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意：【boge】

        1. 方法的参数或局部变量类型必须为接口才能使用Lambda
        2. 接口中有且仅有一个抽象方法(@FunctionalInterface)

5. Lambda表达式的原理【boge】
   匿名内部类在编译的时候会产生一个class文件。

   Lambda表达式在程序运行的时候会形成一个类。
        1. 在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码
        2. 还会形成一个匿名内部类，实现接口，重写抽象方法
        3. 在接口中重写方法会调用新生成的方法
6. 类型推断 【sgg】

   上述 Lambda 表达式中的参数类型都是由编译器推断 得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的 “ 类型推断”

7. Lambda和匿名内部类的对比【boge】

   1. 所需类型不一样

         匿名内部类的类型可以是 类，抽象类，接口

         Lambda表达式需要的类型必须是接口

   2. 抽象方法的数量不一样

         匿名内部类所需的接口中的抽象方法的数量是随意的

         Lambda表达式所需的接口中只能有一个抽象方法

   3. 实现原理不一样

         匿名内部类是在编译后形成一个class

         Lambda表达式是在程序运行的时候动态生成 class
    

一 生活中的需求：Runnable接口、run()方法

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Ex01 {
    public static void main1(String[] args) {
        //  我们在创建线程并启动时可以使用匿名内部类的写法：
        new Thread(new Runnable() {
            public void run() {
                System.out.println("你知道吗 我比你想象的 更想在你身边01");
            }
        }).start();
    }
}
class Ex11{
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println("你知道吗 我比你想象的 更想在你身边02");
        }).start();
    }
}

二 生活中的需求：无参无返回值的Lambda

public class Ex6 {
    public static void goShow(UserService userService){
        userService.show();
    }
    public static void main(String[] args) {
        //  非lambda，匿名内部类的写法调用该方法
        goShow(
                new UserService() {
                    @Override
                    public void show() {
                            System.out.println("show 方法执行了...");
                    }
        });

        //  lambda
        goShow(
                ()
                ->
                { System.out.println("Lambda show 方法执行了..."); }
        );
    }
}
interface UserService {
    void show();
}

三 生活中的需求：有参无返回值的Lambda

import java.sql.SQLOutput;

public class Ex05 {
    public static void foreachArr(IntConsumer consumer){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            consumer.accept(i);
        }
    }

    public static void main(String[] args) {
        //  非lambda，匿名内部类的写法调用该方法
        foreachArr(new IntConsumer() {
            public void accept(int value) {
                System.out.println(value);
            }
        });

        //  lambda格式
        foreachArr(
                (int value)
                ->
                {
                    System.out.println(value);
                }
        );
    }
}

interface IntConsumer{
    void accept(int value);
}

四 生活中的需求：有参有返回值的Lambda

public class Ex03 {
    public static void printNum(IntPredicate predicate){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            if(predicate.test(i)){
                System.out.println(i);
            }
        }
    }
   
    public static void main1(String[] args) {
        //  非lambda，匿名内部类的写法调用该方法
        printNum(new IntPredicate() {
            public boolean test(int value) {
                return value%2==0;
            }
        });

        // lambda格式
        printNum(
            (int value)
            -> 
            {
                return value%2==0;
            }
        );
    }
}
interface IntPredicate{
    boolean test(int value);
}

public class Ex04 {
    public static <R> R typeConver(Function<String,R> function){
        String str = "1235";
        R result = function.apply(str);
        return result;
    }

    public static void main(String[] args) {
        //  非lambda，先使用匿名内部类的写法调用该方法
        Integer result1 = typeConver(new Function<String, Integer>() {
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        });
        System.out.println(result1);

        //  lambda
        Integer result2 = typeConver(
            (String s)
            ->
            {
                return Integer.valueOf(s);
            }
        );
        System.out.println("lambda结果 = "+result2);
    }
}
interface Function<String,Integer>{
    Integer apply(String s);
}

public class Ex02 {
    public static int calculateNum(IntBinaryOperator operator){
        int a = 10;
        int b = 20;
        return operator.applyAsInt(a, b);
    }

    public static void main(String[] args) {
        //  非lambda，先使用匿名内部类的写法调用该方法
        int i1 = calculateNum(new IntBinaryOperator() {
            public int applyAsInt(int left, int right) {
                return left + right;
            }
        });
        System.out.println(i1);

        //  lambda
        int i2 = calculateNum(
            (int left, int right)
            ->
            {
                return left + right;
            }
        );
        System.out.println(i2);
    }
}
interface IntBinaryOperator{
    int applyAsInt(int a,int b);
}

五 生活中的需求：forEach循环：普通、ArrayList、HashMap

import java.util.ArrayList;
import java.util.HashMap;
import java.util.stream.IntStream;

public class ExFor {
    public static void main(String[] args) {
        System.out.println("--------------------------普通的for循环-------------------------------------");
        IntStream.range(0,4).forEach(
            i
            ->
            System.out.println("循环变量i:"+i)
        );


        System.out.println("--------------------------arrayList-------------------------------------");
        int[] index = {0};
        ArrayList list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.forEach(
            e 
            -> 
            {
                index[0] = list.indexOf(e);
                System.out.print("循环变量i："+index[0]+"\t");
                System.out.println("list里面的值："+e);
            }
        );

        System.out.println("--------------------------hashmap-------------------------------------");
        HashMap<String, String> map = new HashMap();
        map.put("1", "张三");
        map.put("2", "李四");
        map.put("3", "王五");
        map.forEach(
            (k,v)
            -> 
            System.out.println("键："+k+",值："+v)
        );
    }
}

六 生活中的需求：接口只能声明一个抽象方法：@FunctionalInterface注解【boge】

/**
  * @FunctionalInterface 
  * 这是一个标志注解，被该注解修饰的接口只能声明一个抽象方法 
  */ 
@FunctionalInterface 
public interface UserService { 
    void show(); 
}