Java中lambda表达式的使用-编程知识

💕"我不要麻木的死去"💕

作者：Mylvzi

文章主要内容：Java中lambda表达式的使用

一.背景

lambda表达式是Java SE 8中一个重要的新特性，允许你使用一个表达式来代替功能接口。lambda表达式可以看作一个没有返回值，没有修饰符修饰的方法，它具有参数和这些参数的主体(方法体)Lambda 表达式（Lambda expression），基于数学中的λ演算得名，也可称为闭包（Closure）

二.语法

1.基本语法

基本语法: (parameters) -> expression 或 (parameters) ->{ statements;

parameters：类似于方法中的形参列表，参数来源于函数式接口的参数
->：可以理解为"被用于"
expression :方法体可以是一条语句也可以是多条语句

2.函数式接口

函数式接口就是只含有一条抽象方法的接口

如果接口上声明了@FunctionalInterface，那么编译器就会按照函数式接口进行检验，也即此接口内部只能有一个抽象方法，但是可以使用default来添加一个非抽象方法

@FunctionalInterface
interface FuncInterface1 {void test();
}// 这样也是可以的
@FunctionalInterface
interface FuncInterface2 {void test();default void test2(){System.out.println("===");}
}

三.lambda表达式的基本使用

lambda表达式就相当于使用一种更简单的方式重写了抽象方法(相比于使用匿名内部类)

1.无返回值，无参数

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {void test();
}

使用两种方式实现

        // 使用lambda表达式重写函数式接口的抽象方法     参数       方法体NoParameterNoReturn noParameterNoReturn1 = () -> System.out.println("hello1");noParameterNoReturn1.test();// 输出hello1// 使用匿名内部类重写函数式接口的抽象方法NoParameterNoReturn noParameterNoReturn2 = new NoParameterNoReturn() {@Overridepublic void test() {System.out.println("hello2");}};

2.无返回值，一个参数

//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {void test(int a);
}

使用两种方式实现

        // 使用lambda表达式OneParameterNoReturn oneParameterNoReturn = (x) -> System.out.println(x);oneParameterNoReturn.test(10);// 打印10// 使用匿名内部类OneParameterNoReturn oneParameterNoReturn1 = new OneParameterNoReturn() {@Overridepublic void test(int a) {System.out.println(a);}};

注意：当参数只有一个或者方法体只有一句时，可以省略外面的();

3.无返回值多个参数

//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {void test(int a,int b);
}

使用两种方式实现

        // 使用lambda表达式MoreParameterNoReturn moreParameterNoReturn = (x,y) -> System.out.println(x+y);moreParameterNoReturn.test(10,20);// 输出30// 使用匿名内部类MoreParameterNoReturn moreParameterNoReturn1 = new MoreParameterNoReturn() {@Overridepublic void test(int a, int b) {System.out.println(a+b);}};

4.有返回值无参数

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {int test();
}

使用两种方式实现

        NoParameterReturn noParameterReturn = () -> {return 10;};System.out.println(noParameterReturn.test());// 输出10// 简化NoParameterReturn noParameterReturn1 = () ->10;System.out.println(noParameterReturn1.test());// 输出10// 使用匿名内部类NoParameterReturn noParameterReturn2 = new NoParameterReturn() {@Overridepublic int test() {return 10;}};

5.有返回值一个参数

//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {int test(int a);
}

使用两种方式实现

        OneParameterReturn oneParameterReturn = (x) -> {return x*x;};System.out.println(oneParameterReturn.test(10));// 输出100// 简化OneParameterReturn oneParameterReturn1 = x -> x*x;System.out.println(oneParameterReturn1.test(10));// 输出100// 使用匿名内部类OneParameterReturn oneParameterReturn2 = new OneParameterReturn() {@Overridepublic int test(int a) {return a*a;}};

6.有返回值多参数

@FunctionalInterface
interface MoreParameterReturn {int test(int a,int b);
}

使用两种方式实现

        MoreParameterReturn moreParameterReturn = (x,y) -> {return x+y;};System.out.println(moreParameterReturn.test(10, 20));// 输出30// 使用匿名内部类MoreParameterReturn moreParameterReturn1 = new MoreParameterReturn() {@Overridepublic int test(int a, int b) {return a+b;}};

四.在优先级队列中的使用

优先级队列中往往涉及到比较，我们在实例化优先级队列的时候往往要传递一个比较器，规定比较的对象

        // 使用匿名内部类实现Comparator接口PriorityQueue<Integer> priorityQueue = new PriorityQueue(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return  o2 - o1;}});

其实也能看出，Comparator方法应该是一个函数式接口，它属于"多个参数，有返回值"的类型(对应于上面的最后一种情况),此处就可以使用lambda表达式进行语法上的精简

        // 使用lambda表达式实现优先级队列中的比较PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((o1,o2) ->{return o1-o2;});

Comparator的源码 -->多个参数，有返回值的接口

五.创建线程

创建线程的方式有很多种，可以采用匿名内部类，lambda表达式

1.匿名内部类创建线程

        // 创建线程 ->使用匿名内部类Thread thread1 = new Thread() {@Overridepublic void run() {System.out.println("hello thread");}};// 这种方式可以降低耦合性(推荐)Thread thread2 = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("hello thread2");}});

为什么可以使用匿名内部类创建一个线程呢？主要是因为Thread类实现了Runnable接口，这个接口是一个函数式接口，只有一个抽象方法run()

2.使用lambda表达式

既然Thread可以通过匿名内部类方式创建线程，同时就可以使用lambda表达式来简化创建

        // 方式1Thread thread1 = new Thread(() ->{System.out.println("hello thread1");});thread1.run();// 输出hello thread1//方式2  利用lambda表达式实例化一个runnable接口  降低耦合性Runnable runnable = () -> System.out.println("hello thread2");Thread thread2 = new Thread(runnable);thread2.run();// 输出hello thread2