java_Lambda表达式

java 函数式编程

推导过程

1. 一个简单的接口使用

2. 静态内部类

   

3.局部内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N4k5D9k4-1664026940810)(…/…/tools/Typora/upload/image-20220924213839600.png)]

5. 匿名内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-doJtKjZ5-1664026940811)(…/…/tools/Typora/upload/image-20220924213947645.png)]

6. 使用lambda简化

为什么学

1. 容于并发编程。可以使用并发 处理大数量集合，自动使用多线程去处理，而自己不用写线程有关代码。
2. 可以简化代码，解决嵌套。

Lambda表达式

Lambda是JDK8中一个语法糖。他可以对某些匿名内部类的写法进行简化。它是函数式编程思想的一个重要体现。让我们不用关注是什么对象。而是更关注我们对数据进行了什么操作。

格式：

(参数列表)->{代码}  

小括号 和 大括号 都还可以省略

语法糖：

简单的说，语法糖就是一种便捷写法。就相当于汉语里的成语。

idea tip:

ctrl+p 查看传参提示

public class LambdaDemo_01 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            public void run() {
     System.out.println("_____新线程中run方法____");
            }
        }).start();
    }

}

上面这个Thread构造需要一个实现了Runnable接口的对象

我们使用了匿名内部类，并且重写了run方法，然后调用了start()。

什么情况可以使用Lambda表达式：

• 上面这种 这个匿名内部类 是一个接口的匿名内部类，并且只需要实现（重写）一个抽象方法（可能接口中其他的是默认方法，就一个是抽象的 ）

  Lambda表达式 不关注类名，方法名，关注的是方法的参数和方法体

  public static void main(String[] args) {
      new Thread(  () -> {System.out.println("_____新线程中run方法____")
      ;}).start();
  }
  

  (参数列表)->{代码} 完成！

下面是几个循序渐进的案例：

public static void main(String[] args) {
    int num = calculateNum(new IntBinaryOperator() {
        @Override
        public int applyAsInt(int left, int right) {
            return left + right;
        }
    });
    System.out.println(num);
}

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

public static void main(String[] args) {
    int num = calculateNum((a,b)->{return a+b ;});
    System.out.println(num);
}


public static int calculateNum(IntBinaryOperator operator) {
    int a = 10;
    int b = 20;
    return operator.applyAsInt(a, b);
}
public static void main(String[] args) {
        int num = calculateNum((a,b)-> a+b);
        System.out.println(num);
    }

tip: 使用idea alt+回车 可以转换匿名内部类到lambda表达式，也可以lambda表达式转换到匿名内部类。

灰常方便

public class LambdaDemo_03 {
    public static void main(String[] args) {
        printNum(new IntPredicate() {
            @Override
            public boolean test(int value) {
                return value%2 == 0;
            }
        });
    }
    
    public static void main(String[] args) {
        printNum((a)->  a%2 == 0);
    }
    
    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 class LambdaDemo_04 {
    public static void main(String[] args) {
        Integer integer = typeConver(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        });

        System.out.println(integer);
    }
    
    public static void main(String[] args) {
        //泛型都省略了
        Integer integer = typeConver(s -> Integer.valueOf(s));

        System.out.println(integer);
    }
    
    public static <R> R typeConver(Function<String,R> function){
        String str = "1235";
        R result = function.apply(str);
        return result;
    }

}

public class LambdaDemo_04 {
    public static void main(String[] args) {
        String st = typeConver(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s+"aaa";
            }
        });

        System.out.println(st);
    }
    
    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) {
       //泛型都可以省略了 
       String st = typeConver(s -> s+"aaa");
        System.out.println(st);
   }

心中目标 就是写一个 实现了哪个方法的，匿名内部类

省略规则

(参数列表)->{代码} 

• 小括号里的 参数类型可省略
• 方法体里只有一句代码时 大括号,return和 最后的分号可省略
• 方法只有 一个参数的时候 小括号可省略

热爱当下 享受当下