JDK8新特性(lambda表达式)

lambda表达式一、Lambda表达式的概念

Lambda表达式:特殊的匿名内部类，语法更简洁

Lambda表达式允许把函数作为一个方法的参数(函数作为方法参数传递),将代码像数据一样传递.

二、Lambda的语法

基本语法：

<函数式接口><变量名>=(参数1,参数二......)->{

//方法体

}

注意:

函数式接口:接口中只有一个抽象方法。

(参数1，参数2): 抽象方法的参数

->: 分隔符

{}：表示抽象方法的实现

三、 Lambda表达式的使用注意事项

四、函数式接口

1.什么是函数式接口?

如果一个接口只有一个抽象方法，则该接口称之为函数式接口，函数式接口可以使用Lambda表达式,Lambda表达式会陪陪到这个抽象方法上。

2.函数式接口注解

@FunctionalInterface:这个注解会检测接口是否符合函数式接口。

五、常见的函数式接口

分析:我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。

在java.util.function保存的常用的函数时接口

1.消费型内置函数接口 Consumer

有参数无返回值

方法：accept(t)

例子：求数组中元素的和

//消费型内置函数接口 Consumer
    //有参无返回值
    //方法为accept(t)
    public static void main(String[] args) {

        fun(arr->{
            int sum = 0;
            for(int n: arr){
                sum+=n;
            }
            System.out.println("和为："+sum);
        });

    }

    public static void fun(Consumer consumer){
        int[] arr={2,3,4,6,2,7,12};
        consumer.accept(arr);
    }

2.供给型内置接口,Supplier

返回类型为T的对象

方法:get()

无参有返回值

例子:生成一个随机数并输出

  //供给型内置接口,Supplier 返回类型为T的对象
    //get()
    //无参有返回值
    public static void main(String[] args) {
        fun(()->new Random().nextInt(10));

    }
    public static void fun(Supplier supplier){
       Integer s = supplier.get();
        System.out.println("生成的随机数为:"+s);
    }

3.函数型内置接口Function

T:参数类型,R返回类型

有参有返回值

方法:function.apply(T)

例子:求一个字符串长度

//函数型内置接口Function T:参数类型,R返回类型
    //方法:function.apply(T)
    //有参有返回值
    public static void main(String[] args) {
        fun((str)->{
            return  str.length();
        },"hello,word!");

    }
    public static void fun(Function function,String msg){
        Integer num = function.apply(msg);
        System.out.println("字符串长度为："+num);
    }

4.断言型内置接口 Predicate

T为参数,返回一个boolean类型的值

当传入一个参数时，需要对该参数进行判断时，则需要这种函数

方法:.test()

有参有返回值(布尔类型)

例子:有没有10个面包

//断言型内置接口 Predicate T为参数,返回一个boolean类型的值
    //当传入一个参数时，需要对该参数进行判断时，则需要这种函数
    //方法:.test()
    //有参有返回值(布尔类型)
    public static void main(String[] args) {
        frun(num->{
            if(num>=10){
                return true;
            }else {
                return false;
            }
        });
    }
    public static void frun(Predicate predicate){
        boolean test = predicate.test(10);
        System.out.println("你有没有10个面包？"+test);
    }

六、方法引用方法引用的使用场景

我们用Lambda表达式来实现匿名方法。但有些情况下，我们用Lambda表达式仅仅是调用一些已经存在的方法，除了调用方法外，没有其他任何多余的动作，在这种情况下，我们倾向于通过方法名来调用它，而Lambda表达式可以帮助我们实现这一要求，它使得Lambda在调用那些已经拥有方法名的方法的代码更简洁、更容易理解。方法引用可以理解为Lambda表达式的另外一种表现形式。

方法引用的分类

类型	语法	对应的Lambda表达式
静态方法引用	类名::staticMethod	(args) -> 类名.staticMethod(args)
实例方法引用	inst::instMethod	(args) -> inst.instMethod(args)
对象方法引用	类名::instMethod	(inst,args) -> inst.instMethod(args)
构建方法引用	类名::new	(args) -> new 类名(args)

方法引用的分析(Lambda表达式的冗余)

如果我们在Lambda中所指定的功能，已经有其他方法存在相同方案，那是否还有必要再写重复逻辑？可以直接“引用”过去就好了：---方法引用。

1. 静态方法引用

例子:

package com.gsh.demon_05;

import java.util.function.Consumer;


public class TestStaticM {
    //静态方法的引用:
    //因为这个类中已经存在了一个静态的数组求和的方法,我们可以直接调用静态方法来进行引用
    public static void main(String[] args) {
        //第一种方法:参数->类名.方法名(参数)
        //fun(arr->TestStaticM.sumArray(arr));
        //第二种:类名::方法名
        fun(TestStaticM::sumArray);

    }
    //自己的数组求和的方法
    public  static void sumArray(Integer[] arr){
       Integer sum=0;
        for (Integer integer : arr) {
            sum+=integer;
        }
        System.out.println("数组中的和为:"+sum);
    }
    public static void fun(Consumer consumer){
        Integer[]num={1,2,3,4,5,6,7,9,10};
        consumer.accept(num);
    }
}

2. 实例方法引用

实例方法引用，顾名思义就是调用已经存在的实例的方法，与静态方法引用不同的是类要先实例化，静态方法引用类无需实例化，直接用类名去调用。

例子:

package com.gsh.demon_05;

import java.util.function.Supplier;


public class TestInstM {
    //实例方法的引用
    //实例方法引用，顾名思义就是调用已经存在的实例的方法，
    // 与静态方法引用不同的是类要先实例化，静态方法引用类无需实例化，直接用类名去调用。
    public static void main(String[] args) {
        Student student=new Student("张三",21);
        //实例方法引用
        //第一种:
        //fun(()->student.getName());
        //第二种:
        fun(student::getName);

    }

    public static void fun(Supplier supplier){
        String s = supplier.get();
        System.out.println("姓名为:"+s);
    }

}
class Student{
    private String name;
    private Integer age;

    public Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

3.对象方法引用

对象方法引用: 类名::实例方法. (参数1,参数2)->参数1.实例方法(参数2)

 //对象方法引用
    public static void main(String[] args) {
        fun(String::equals);
    }
    public static void fun(BiFunction booleanBiFunction){
        Boolean aBoolean = booleanBiFunction.apply("hello", "hello");
        System.out.println(aBoolean);
    }

4.构造方法引用

构造方法引用: 类名::new (参数)->new 类名(参数)

package com.gsh.demon_05;

import java.util.function.Function;
import java.util.function.Supplier;


public class TestConM {
    public static void main(String[] args) {
        //构造方法引用
        Function function=Food :: new;
        Food food=function.apply("苹果");
        System.out.println(food);

    }
}
class Food{
    private String name;

    @Override
    public String toString() {
        return "Food{" +
                "name='" + name + ''' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Food() {
    }

    public Food(String name) {
        this.name = name;
    }
}

JDK8新特性(lambda表达式)

Java相关栏目本月热门文章