浅谈lambda表达式——建议收藏

        lambda表达式并不建议频繁使用，如果频繁使用会使你的代码非常简洁但是让人难以理解，后期会难以维护，同事看了想打人系列。

说明：

lambda是java8中引入的一个新的操作符“->”，成为箭头操作符或者是lambda操作符。

左侧：lambda表达式的参数列表。

右侧：lambda表达式中所需执行的功能，即lambda体。

依赖于函数式接口，lambda表达式即对接口的实现。

特点：

1.lambda使句式变得更加简洁。

话不多说上栗子：

 @Test
    void contextLoads() {
        //未使用lambda表达式
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("404");
            }
        };
        //使用lambda表达式
        Runnable runnable2=()->System.out.println("404");
    }

很明显可以看出使用lambda表达式和不使用的差距在哪里。

2.lambda中的变量

栗子：

       int s=5;
        Runnable runnable2=()->System.out.println(s++);

这句话是会报错的，原因是当用lambda去调用局部变量时会自动用final修饰

---

虽然常量无法改变，但是我们可以定义数字，改变数组中的数值

  int[] ss=new int [1];
        ss[0]=1;
        Runnable runnable2=()->{
            ss[0]++;
            System.out.println( );
        };

这样就不报错了

 3.有一个参数值

Consumer<String> consumer = (x)->{System.out.println(x);};
consumer.accept("s886");

这段代码就是将accept得到的参数作为x然后输出。

4.只有一个参数，省略括号

Consumer<String> consumer = x->{System.out.println(x);};
consumer.accept("ssssss");

当只有一个参数时，（）可以省略，lambda表达式的宗旨就是能省则省。

5.有两个参数以上，有返回值且有多条语句

Comparator<Integer> consumer1 = (x, y)->{
      System.out.println("ISO-8859-1");
      return Integer.compare(x,y);
};

参数的小括号不能省略，需要去return。

6.lambda中只有一条语句时

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

{}和return都可以省略

四大内置函数：

lambda表达式依赖的常见四大内置函数。

类型	类	抽象方法
消费型接口	Consumer<T>	void accept(T t)
供给型接口	Supplier<T>	T get();
函数型接口	Function<T,R>	R apply(T t)
断言型接口	Predicate<T>	boolean test(T t)

自定义函数接口：

1.数字型

  public static  List<Integer> Number (int n, Supplier<Integer> s){
        List<Integer> list =new ArrayList<>();
        for(int i=0;i<n;i++){
            list.add(s.get());
        }
        return list;
    }
    public static void main(String[] args) {
        List<Integer> num = Number(4,()->(int)(Math.random()*100));
        num.forEach(System.out::println);
    }

        上面是我们定义的方法，第一次参数n就是我们需要添加数字的数量，第二个参数就是一个供给型的函数接口。

（如何快速生成 List<Integer> list =new ArrayList<>();

传送门 idea自动补全代码，一秒生成new List，写代码更便捷，快捷方法！_非又肝的博客-CSDN博客）

2.字符串型

  public static String Str(String str, Function<String ,String>fun){
        return fun.apply(str);
    }
    public static void main(String[] args) {
        String re  = Str("404+",(x)->x+"505");
        System.out.println(re);

    }

        第一个参数就是一个字符串，第二个参数是函数型接口，调用时我们将x+"字符串"赋值给re，然后输出。

方法引用：

1.对象：：实例化方法名

   @Test
    public void test1(){
        Consumer<String> con = System.out::println;
        con.accept("asdasd");
    }

2.类：：静态方法名

  @Test
    public void test2(){
        Comparator<Integer> com1 =(x,y)->Integer.compare(x,y);
        Comparator<Integer> com2 = Integer::compare;
    }

这两种方法是等价的，第二种方法相当于直接调用了Integer中的静态方法compare。

3.类：：实例方法名

  @Test
    public void test3(){
        BiPredicate<String,String> com1 =(x, y)->x.equals(y);
        BiPredicate<String,String> com2 = String::equals;
    }

这两种方法是等价的，但是第二种方法中，第一个参数是方法的调用者，第二个参数是方法的参数。