lambda表达式的核心目的,lambda配合流使用,本质是什么,口语化解释,简写的方式

文章目录

  • 1、lambda表达式本质是解决匿名内部类的问题
  • 2、说说lambda表达式最入门的应用,实现一个函数式接口,对比匿名内部类
  • 3、lambda表达式常常配合stream一起使用,来看看更抽象的使用
  • 4、继续深入理解stream中的lambda表达式
  • 5、作者的源码程序:
    • 5.1、lambda表达式常常配合stream一起使用
  • 6、其他
    • lambda表达式中的::运算符,原理是eta转换
    • 对方法引用的官方理解
    • 如果需要打好lambda基础,深入学习,可以看看千峰的课程,大致内容如下

1、lambda表达式本质是解决匿名内部类的问题

如果你理解了这句话实际上就理解了lambda表达式,如果你不理解那么lambda表达式看得将会特别难受。实际上解决了匿名内部类的问题,代码自然而然就变得简洁了,如果你对lambda表达式理解得不深,那么lambda写出来的程序你将会觉得可读性很差,但是在作者眼中lambda表达式可读性和正常程序一样,甚至看的速度更快,更快上手。

2、说说lambda表达式最入门的应用,实现一个函数式接口,对比匿名内部类

  • 匿名内部类写法
Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类跑起来了");
            }
        };
  • lambda表达式写法
Runnable runnable1=()-> System.out.println("lambda表达式跑起来了");
  • 作者写的测试程序
public class Main {


    public static void main(String[] args) {


        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类跑起来了");
            }
        };
        Runnable runnable1 = () -> System.out.println("lambda表达式跑起来了");
        runnable.run();
        runnable1.run();

    }

}

总结:这种程序简单易懂,一看就懂,实际上两种实现方式自己的效果是一样的。lambda表达式最经典的实现一个匿名内部类

3、lambda表达式常常配合stream一起使用,来看看更抽象的使用

  • 核心代码
list.stream().filter((e)->e.getAge()>18).forEach(System.out::println);      //打印出年龄大于18的Employees

很多新手看到这个lambda表达式一瞬间就觉得晦涩难懂,不能理解,它是如何工作的,听我细细说来。

  • 我们先用传统的思维,看filter方法需要传入什么参数,下面是源码,可知需要传入一个Predicate类型的匿名内部类
    Stream<T> filter(Predicate<? super T> predicate);
  • 我们用传统的思维去写一个 Predicate 匿名内部类,再传入filter方法
   Predicate<Employees>  predicate=(e)->e.getAge()>18;
   list.stream().filter(predicate).forEach(System.out::println);	//实现的效果完全和上面的相等

结论:在这一句 list.stream().filter((e)->e.getAge()>18).forEach(System.out::println); 中lambda表达式 (e)->e.getAge()>18 通过反射得知要实现什么函数接口并传入方法中,所以在表达式中没有显示出类型,但是实际上系统已经替我们做了这些。

4、继续深入理解stream中的lambda表达式

程序一:

  • lambda表达式
list.stream().filter((e)->e.getAge()>18).forEach(System.out::println);      //打印出年龄大于18的Employees
  • filter方法
Stream<T> filter(Predicate<? super T> predicate);

程序二:

  • lambda表达式
list.stream().map(e->e.getName()).forEach(System.out::println);   //通过打印出所有名字
  • map方法
<R> Stream<R> map(Function<? super T, ? extends R> mapper);

结论:在程序一filter需要传入的Predicate接口实例,所以lambda表达式实现的是Predicate接口,在程序二中map需要传入的是Function接口实例,所以lambda表达式实现的是Function接口。所以在不同的方法中lambda表达式会通过反射得知需要实现什么接口并自动生成。

5、作者的源码程序:

5.1、lambda表达式常常配合stream一起使用

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Main02 {

    //声明一个静态内部类
    public static class Employees {

        private Student student;
        //String类型的类变量name
        private String name;
        //int类型的类变量age
        private int age;
        //double类型的类变量salary
        private double salary;
        //无参数的构造方法
        public Employees() {}
        //带所有类变量的构造方法
        public Employees(String name, int age, double salary) {
            //初始化类变量
            this.name = name;
            //初始化类变量
            this.age = age;
            //初始化类变量
            this.salary = salary;
        }
        //get()/set()方法
        public String getName() {
            return name;
        }
        //get()/set()方法
        public void setName(String name) {
            this.name = name;
        }
        //get()/set()方法
        public int getAge() {
            return age;
        }
        //get()/set()方法
        public void setAge(int age) {
            this.age = age;
        }
        //get()/set()方法
        public double getSalary() {
            return salary;
        }
        //get()/set()方法
        public void setSalary(double salary) {
            this.salary = salary;
        }
        //toString()方法
        public String toString() {
            //返回所有的类变量的值。
            return "Employees [name=" + name + ", age=" + age + ",salary=" + salary + "]";
        }
    }


    public static void main(String[] args) {

        //目标list:
        //利用Employees对象创建一个List类型的集合(这里还使用了类
        //Arrays的方法asList(T...a)进行了转换)。
        //注意使用泛型
        List<Employees> list = Arrays.asList(
                new Employees("张三",18,9999.99),
                new Employees("李四",38,5555.55),
                new Employees("王五",50,6666.66),
                new Employees("赵六",16,3333.33),
                new Employees("田七",8,8888.88)
        );
        list.stream().filter((e)->e.getAge()>18).forEach(System.out::println);      //打印出年龄大于18的Employees
        System.out.println("等效于:");
        Predicate<Employees>  predicate=(e)->e.getAge()>18;
        list.stream().filter(predicate).forEach(System.out::println);
        System.out.println("==============================");
        list.stream().map(e->e.getName()).forEach(System.out::println);   //通过打印出所有名字
    }
}

6、其他

lambda表达式中的::运算符,原理是eta转换

  • 双冒号运算就是Java中的[方法引用],[方法引用]的格式是 类名::方法名。一般是用作Lambda表达式
  • 简单举例,上面的是lambda表达式,下面的等价的方法引用
number -> Math.abs(number);
Math::abs
person -> person.getName();
Person::getName
() -> new HashMap<>();
HashMap::new
(a, b)->Math.max(a, b);
Math::max
(a, b) -> Person.compareByAge(a, b)
Person::compareByAge

对方法引用的官方理解

  • 英文格式双冒号::,读:double colon,双冒号(::)运算符在Java 8中被用作方法引用(method reference),方法引用是与lambda表达式相关的一个重要特性。它提供了一种执行方法的方法,为此,方法引用需要由兼容的函数式接口组成的目标类型上下文。

  • Method References(关于方法引用的描述-来自Oracle官网)
    You use lambda expressions to create anonymous methods. Sometimes, however, a lambda expression does nothing but call an existing method. In those cases, it’s often clearer to refer to the existing method by name. Method references enable you to do this; they are compact, easy-to-read lambda expressions for methods that already have a name.

  • 大概意思就是,使用lambda表达式会创建匿名函数, 但有时候需要使用一个lambda表达式只调用一个已经存在的方法(不做其它), 所以这才有了方法引用!

如果需要打好lambda基础,深入学习,可以看看千峰的课程,大致内容如下

  • 讲解视频链接
  • 笔记链接

参考文档:

  • java 双冒号是什么操作符?
  • 笃学私教:如何理解并使用Java中双冒号(::)运算操作符
  • 深入理解Java双冒号(::)运算符的使用

你可能感兴趣的:(日常笔记,数据库,sql,查询)