新特性--Lambda表达式(函数式编程思想)_lambda表达式新特性介绍-CSDN博客

本文链接：https://blog.csdn.net/weixin_51338804/article/details/118551235

一：Lambda表达式介绍

1.概念：Lambda表达式是Java8中最重要的新功能之一。使用Lambda表达式可以替代只有一个抽象函数的接口实现，告别匿名内部类，代码看起来更简洁易懂。Lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤数据的操作；

2.特点：1）函数式编程；

2）参数类型自动推断；

3）代码量少，简洁；

3.应用场景：任何有函数式接口的地方；

3.代码实现：

package com.cy;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LambdaDemo {

    public static void main(String[] args) {
     //===========功能一：替代匿名内部类=================================
        //方式一：匿名内部类的方式
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("running---");
            }
        });
        thread.start();

        //方式二：采用Lambda表达式的方式
        new Thread(()->{
            System.out.println("running++++");
        }).start();


    //==============功能二：==============================================
        //采用匿名内部类的方式
        List<String> list= Arrays.asList("java","js","scala","python");
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        for (String str:list) {
            System.out.println(str);
        }

        //采用Lambda表达式的方式
        Collections.sort(list,(a,b)->a.length()-b.length());
        list.forEach(System.out::println);

    }

}

表达式案例：

()->{}

()->{System.out.println(1);}

()->System.out.println(1)

()->{return 100;}

()->100

()->null

(int x)->{return x+1;}

(int x)->x+1

(x)->x+1

x->x+1

args->expr或者（object ... args）->{函数式接口抽象方法实现逻辑}

1、（）参数的个数，根据函数式接口里面抽象的参数个数来决定，当参数只有一个的时候，（）可以省略

2、当expr逻辑非常简单的时候，{}和return可以省略

package com.lambda;

import com.why.Student;

public class LambdaTest {

    public static void main(String[] args) {
        StudentDao sd1= new StudentDao() {
            @Override
            public void insert(Student student) {
                System.out.println("插入学生1");
            }
        };

        StudentDao sd2=(student) -> {
            System.out.println("student"+student);
        };

        StudentDao sd3=(Student student)-> System.out.println("student3"+student);

        sd1.insert(new Student());
        sd2.insert(new Student());
        sd3.insert(new Student());

        TeacherDao teacherDao=new TeacherDao() {
            @Override
            public int get(Teacher teacher) {
                return 1;
            }
        };

        TeacherDao teacherDao1=(teacher)->{ return 2;};
        TeacherDao teacherDao2=(Teacher teacher)->{return 3;};
        TeacherDao teacherDao3=(teacher)->4;
        TeacherDao teacherDao4=(Teacher teacher)->5;

        System.out.println(teacherDao.get(new Teacher()));
        System.out.println(teacherDao1.get(new Teacher()));
        System.out.println(teacherDao2.get(new Teacher()));
        System.out.println(teacherDao3.get(new Teacher()));
        System.out.println(teacherDao4.get(new Teacher()));

    }
}

二：函数式接口

概念：只有一个抽象方法（Object类里的方法除外）的接口是函数式接口；

代码案例：

package com.cy;

/**
 * 函数式接口
 */
@FunctionalInterface//函数式接口标识注解
public interface InterfaceTest {

    public void add();

}

三：方法的引用

1.概念：方法的引用是用来直接访问类或实例的已经存在的方法或者构造方法，方法的引用提供了一种引用而不执行的方式，如果抽象的方法实现恰好可以使用调用另外一个方法来执行，就有可能使用方法来执行；

2.分类：

3.代码实现：

package com.function.refer;

import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class Test02 {

    public static void main(String[] args) {
        //静态方法引用
        staticMethod();
        //实例方法引用
        newMethod();
        //对象方法引用
        objectMethod();
        //构造方法引用
        constructorMethod();
    }

    /**
     * 静态方法引用
     */
    public static void staticMethod(){
        //方式一：直接调用
        System.out.println(put());
        //方式二：使用Lambda表达式调用；
        Supplier<String> stringSupplier=()->Test02.put();
        System.out.println(stringSupplier.get());

        //方式三：使用方法引用的方式调用
        Supplier<String> str=Test02::put;
        System.out.println(str.get());

        Supplier<String> str2=Fun::hehe;
        System.out.println(str2.get());

        Consumer<Integer> c2=Test02::countSize;
        Consumer<Integer> c3=(size)->Test02.countSize(size);
        c2.accept(123);
    }

    public static String put(){
        System.out.println("put.....");
        return "put";
    }


    public static void countSize(int size){
        System.out.println(size);
    }

    /**
     * 实例方法引用
     */
    public static void newMethod(){
        //方式一：直接调用
        System.out.println(new Test02().insert());
        //方式二：使用Lambda表达式的方式引用
        Supplier<String> stringSupplier=()->new Test02().insert();
        System.out.println(stringSupplier.get());
        //方式三：使用方法的引用调用
        Supplier<String> stringSupplier1=new Test02()::insert;
        System.out.println(stringSupplier1.get());

        //创建唯一的Test02对象
        Test02 test02 = new Test02();

        Consumer<Integer> c1=(size)->new Test02().getSize(size);
        Consumer<Integer> c2=new Test02()::getSize;
        Consumer<Integer> c3=test02::getSize;
        c1.accept(123);
        c2.accept(123);
        c3.accept(123);
    }

    public String insert(){
        return "insert--";
    }

    public void getSize(int size){
        System.out.println("size:"+size);
    }

    /**
     * 对象方法引用
     */
    public static void objectMethod(){
        //方式一：使用Lambda表达式调用
        Consumer<Fun> f1=(Fun f)->new Fun().foo();
        f1.accept(new Fun());

        //方式二：使用方法引用调用
        Consumer<Fun> f2=Fun::foo;
        f2.accept(new Fun());

        BiFunction<Fun,String,Integer> fun=(f,str)->new Fun().fun(str);
        System.out.println(fun.apply(new Fun(),"abc"));

        BiFunction<Fun,String,Integer> function=Fun::fun;
        System.out.println(function.apply(new Fun(),"abc"));
    }


    /**
     * 构造方法调用
     */
    public static void constructorMethod(){

        Supplier<Person> s1=()->new Person();
        s1.get();

        Supplier<Person> s2=Person::new;
        s2.get();

        Consumer<Integer> c1=(age)->new Person(age);
        c1.accept(123);

        Consumer<String> c2=(name)->new Person(name);
        c2.accept("wzh");
     }

}

class Fun{
    public static String hehe(){
        return "hehe";
    }

    public Integer fun(String s){
        return s.length();
    }

    public void foo(){
        System.out.println("foo---");
    }
}

class Person{
    public Person() {
        System.out.println("无参构造方法执行了");
    }

    public Person(int age){
        System.out.println(age+" 的构造法");
    }

    public Person(String name){
        System.out.println(name+"的构造方法");

    }
}