Java中Lambda表达式详解

喜欢ヅ旅行 2023-10-18 21:41 134阅读 0赞

最后更新时间:2020年10月23日10点16分

目录

一、函数式编程思想概述

1、概述

2、面向对象的思想

3、函数式编程思想

二、冗余的代码案例(Runnable)

RunnableImpl类:

RunnableImplTest类:

三、编程思想转换和体验Lambda

1、我们真正的目的是什么:关注做什么,而不是怎么做

2、代码演示(比较):

匿名内部类实现方式:

Lambda表达式实现方式:

四、Lambda表达式的标准格式

1、3部分组成

2、标准格式及其说明

五、无参无返回值案例

接口:

测试类:

六、有参有返回值案例

代码示例:

接口:

测试类:

七、Lambda表达式省略式

1、Lambda表达式

2、可省略的内容

3、测试类省略之后

4、注意

八、Lambda发展由来

1、代码简化历程

2、代码实现

3、运行结果


一、函数式编程思想概述

1、概述

在数学中,函数就是输入量、输出量的一套计算方案,也就是“拿什么东西,做什么事情”。相对而言,面向对象过分强调“必须通过对象的形式来做事情”,而函数式编程则尽量忽略面向对象的复杂语法——强调做什么,而不是以什么形式做。

2、面向对象的思想

做一件事情,找到能做这个事情的对象,调用对象的方法,完成事情;

3、函数式编程思想

只要能获取结果,谁去做的,怎么做的都不重要(结果重要,过程不重要);

二、冗余的代码案例(Runnable)

RunnableImpl类:

  1. package study.lambda;
  2. public class RunnableImpl implements Runnable {
  3. @Override
  4. public void run() {
  5. System.out.println(Thread.currentThread().getName()+"==========");
  6. }
  7. }

RunnableImplTest类:

  1. package study.lambda;
  2. public class RunnableImplTest {
  3. public static void main(String[] args) {
  4. //1、一般写法
  5. RunnableImpl runnable = new RunnableImpl();
  6. Thread thread = new Thread(runnable);
  7. thread.start();
  8. //2、简化写法
  9. Runnable runnable1 = new Runnable(){
  10. @Override
  11. public void run() {
  12. System.out.println(Thread.currentThread().getName()+"==========");
  13. }
  14. };
  15. new Thread(runnable1).start();
  16. //3、再简化
  17. new Thread(new Runnable() {
  18. @Override
  19. public void run() {
  20. System.out.println(Thread.currentThread().getName()+"==========");
  21. }
  22. }).start();
  23. //由上可知,无论怎么简化都是很麻烦的,实际有用的代码只有一行
  24. }
  25. }

由上可知,无论怎么简化都是很麻烦的,实际有用的代码只有一行。

三、编程思想转换和体验Lambda

1、我们真正的目的是什么:关注做什么,而不是怎么做

将run方法内部的代码块传递给Thread类;

2、代码演示(比较):

匿名内部类实现方式:

  1. new Thread(new Runnable() {
  2. @Override
  3. public void run() {
  4. System.out.println(Thread.currentThread().getName()+"==========");
  5. }
  6. }).start();

Lambda表达式实现方式:

  1. new Thread(()->{
  2. System.out.println(Thread.currentThread().getName()+"==========");
  3. }).start();
  4. //而且在当只有一行输出语句的时候可以省略大括号和分号,如下:
  5. new Thread(()->System.out.println(Thread.currentThread().getName()+"==========")).start();

四、Lambda表达式的标准格式

1、3部分组成

一些参数,一个箭头,一段代码;

2、标准格式及其说明

  1. (参数列表) -> { 代码语句 }
  2. ():接口中抽象方法的参数列表;
  3. ->:将参数传递给方法体的意思;
  4. {}:重写的抽象方法的方法体;

五、无参无返回值案例

接口:

  1. package study.lambda;
  2. public interface Cook {
  3. void make();
  4. }

测试类:

  1. package study.lambda;
  2. public class Test {
  3. public static void main(String[] args) {
  4. cook1(() -> System.out.println("做饭啦"));
  5. }
  6. //写一个方法调用接口的方法
  7. private static void cook1(Cook cook){
  8. cook.make();
  9. }
  10. }

六、有参有返回值案例

代码示例:

常规来讲,用方法调用接口内方法时,将其他参数放在接口前

接口:

  1. package study.lambda;
  2. public interface Cook {
  3. String make(String string);
  4. }

测试类:

  1. package study.lambda;
  2. public class Test {
  3. public static void main(String[] args) {
  4. String string = cook1("我就是参数啦",(String string1) -> {
  5. return string1+"======这就是返回值你信不信!"
  6. });
  7. System.out.println(string);//我就是参数啦======这就是返回值你信不信!
  8. }
  9. //写一个方法调用接口的方法
  10. private static String cook1(String string,Cook cook){
  11. return cook.make(string);
  12. }
  13. }

七、Lambda表达式省略式

1、Lambda表达式

可推导,可省略;

凡是可以通过上下文推到出来的内容,都可以省略;

2、可省略的内容

①(参数列表):括号中参数列表的数据类型可以省略不写;

②(参数列表):若括号中只有一个参数,那么括号也可以省略不写;

③{一些代码}:如果代码只有一行,({},return,分号;)可以省略不写,要省略3个必须一起省略;

3、测试类省略之后

  1. package study.lambda;
  2. public class Test {
  3. public static void main(String[] args) {
  4. String string = cook1("我就是参数啦",string1 -> string1+"======这就是返回值你信不信!");
  5. System.out.println(string);//我就是参数啦======这就是返回值你信不信!
  6. }
  7. //写一个方法调用接口的方法
  8. private static String cook1(String string,Cook cook){
  9. return cook.make(string);
  10. }
  11. }

4、注意

①使用Lambda抽象类必须是“有且仅有一个抽象方法”(这样的接口也成为了函数式接口);

②使用Lambda必须具有上下文推断;

八、Lambda发展由来

1、代码简化历程

普通类实现接口——静态内部类实现接口——局部内部类实现接口——匿名内部类实现接口——Lambda表达式实现接口;

2、代码实现

  1. package com.zb.thread;
  2. public class Main {
  3. public static void main(String[] args) {
  4. //4、局部内部类实现接口
  5. class Pig implements Action{
  6. @Override
  7. public void go() {
  8. System.out.println("猪行走!");
  9. }
  10. }
  11. //常规实现
  12. Action action = new Cat();
  13. action.go();
  14. //简化:静态内部类
  15. action = new Dog();
  16. action.go();
  17. //再简化:局部内部类实现接口
  18. action = new Pig();
  19. action.go();
  20. //再简化:匿名内部类实现接口
  21. action = new Action() {
  22. @Override
  23. public void go() {
  24. System.out.println("(匿名内部类)不知道是谁在走!");
  25. }
  26. };
  27. action.go();
  28. //再简化:Lambda表达式实现接口
  29. //我们可以明白,最重要的信息就是参数、方法
  30. action = () -> System.out.println("(Lambda表达式)不知道是谁在走!");
  31. action.go();
  32. }
  33. //3、静态内部类实现接口
  34. static class Dog implements Action{
  35. @Override
  36. public void go() {
  37. System.out.println("狗行走!");
  38. }
  39. }
  40. }
  41. //1、创建一个函数式接口(只有一个方法的接口)
  42. interface Action{
  43. void go();
  44. }
  45. //2、普通类实现接口
  46. class Cat implements Action {
  47. @Override
  48. public void go() {
  49. System.out.println("猫咪走路!");
  50. }
  51. }

3、运行结果

  1. 猫咪走路!
  2. 狗行走!
  3. 猪行走!
  4. (匿名内部类)不知道是谁在走!
  5. Lambda表达式)不知道是谁在走!

发表评论

表情:
评论列表 (有 0 条评论,134人围观)

还没有评论,来说两句吧...

相关阅读

    相关 java lambda表达式详解

    一、Lambda初识 我们知道,在Java中,接口是不能实例化的,但是接口对象可以指向它的实现类对象。如果接口连实现对象都没有呢?那还可以使用匿名类的方式,如下: