JDK1.8新特性——lambda表达式和函数式接口

已于 2023-03-03 11:06:23 修改
阅读量453 收藏
点赞数
分类专栏： JDk8新特性 文章标签： github java spring 后端 开发语言
于 2022-07-23 16:10:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xzh_java/article/details/125948665
版权

一、lambda表达式

1、概念

  • Lambda表达式时一种特殊的匿名内部类，语法更加简洁。
  • Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递

        这里的匿名内部类的理解，我们可以在下述情况中来帮助大家了解。

        我们都知道，接口是不能直接进行new的，即接口没有实例对象。那么我们之前想要new对象是不是还需要写该接口的一个实现类，然后再去new这个接口实现类的实例对象？

        在某些情况下，我们想要的也许只是接口中的一个抽象方法，其他的内容对我们来说都不重要，那么我们可以直接用接口的匿名内部类的方法来“new 这个接口”。

 对于这个Runnable接口，我们可以直接new他的匿名内部类。

package demo01;

public class LambdaTest {
    public static void main(String[] args) {
        //匿名函数内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名函数内部类");
            }
        }).start();
}

        对于这一部分，都是他的匿名内部类。Lambda表达式就是一种特殊的匿名内部类。他的语法更加简洁。

注意，想要将匿名内部类改写为Lambda表达式的前提是，该接口必须为函数式接口（接口中只能有一个抽象方法的接口称为函数式接口）。

2、语法

<函数式接口> <变量名> = （参数1，参数2) ->{方法体};

 注意:

  • (参数1，参数2): 抽象方法的参数
  • ->: 分隔符
  • { }：表示抽象方法的实现

        我们还是用Runnable接口来举例子。Runnable接口就是一个函数式接口 

        下边的代码就是Lambda表达式。他完全等价于上边匿名内部类的代码。

        再强调一遍，想要使用Lambda表达式，该接口必须是函数式接口！

3、详细介绍Lambda表达式

    1.Lambda表达式引入了新的操作符：->（箭头操作符），该操作符将表达式分成了两部分：

    2.左侧：（参数1，参数2，...）表示参数列表（接口中抽象方法需要的参数列表）
    3.右侧："{}"的内部是方法体
 

注意事项

    参数列表的数据类型会自动推断。我们在左侧括号内写参数列表时，不需要写参数的参数类型，直接写参数名即可。
    如果参数列表为空，我们只需要写一个（）即可（例如上面的Runnable接口中的run方法就的参数列表就为空）
    如果参数列表只有一个，那么（）可以省略，只需要写参数的名称即可
    如果执行的语句只有一句，且无返回值，那么“{ }”可以省略不写；如果执行语句有返回值且只有一句，那么在省略“{ }”的同时，也要省略掉“return”关键字
    Lambda不会生成一个单独的内部类文件

二、函数式接口 

1、概念

  • 如果一个接口只有一个抽象方法，则该接口称之为函数式接口，函数式接口可以使用lambda表达式，Lambda表达式会被匹配到这个抽象方法上
  • @FunctionalInterface 注解会检测接口是否符合函数式接口

 2、内置函数式接口 

        举个例子，我们想要用Lambda表达式来实现数组求和，就需要有一个函数式接口，那么我们就必须先定义一个函数式接口 

    @FunctionalInterface
    interface Operater{
        //求数组的和
        public abstract void getSum(int[] arr);
    }

        然后再实现我们的求和功能

public class Test {
 
    public static void main(String[] args) {
        Operater o=arr -> {
             int sum=0;
             for(int n:arr){
                 sum+=n;
             }
            System.out.println("数组的和为:"+sum);
        };
 
        fun(o);
    }
 
    public static void fun(Operater operater){
         int[] arr={2,3,4,5,6,7,11};
         operater.getSum(arr);
    }
 
}

        我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。这些接口都在java.util.function包下保存

        这四种函数式接口我们都举一个例子来方便大家理解：

        还是用我们的数组求和的代码。我们用Consumer，Supplier，Function这三种函数式接口对其进行改写，最后Predicate我们单独举个例子。

   自定义函数式接口实现数组求和的代码：

package FunctionalInterfaceTest;
 
/**
 * @作者：徐志豪
 * @创建时间 2022/7/19 20:03
 * 求数组的和 ---- 传统形式
 **/
public class TraditionalMethod {
    public static void main(String[] args) {
        Num num = (arr)->{
            int sum = 0;
            for (Integer integer : arr) {
                sum+=integer;
            }
            System.out.println(sum);
        };
        fun(num);
    }
 
    public static void fun(Num num){
        Integer[] arr = {1,2,3,4,5,6,7,8,9};
        num.getNum(arr);
    }
 
}
 
interface Num{
    public void getNum(Integer[] arr);
}

 2.1 Consumer<T> 消费型函数式接口 有参无返回值

T：参数类型的泛型

该函数式接口的抽象方法为  accept( 参数名 );

package FunctionalInterfaceTest;
 
import java.util.function.Consumer;
 
/**
 * @作者：徐志豪
 * @创建时间 2022/7/19 20:12
 * 求数组的和
 * 有参无返   消费型
 **/
public class ConsumerMethod {
    public static void main(String[] args) {
        Consumer<Integer[]> consumer = (arr)->{
            int sum = 0;
            for (Integer integer : arr) {
                sum+=integer;
            }
            System.out.println(sum);
        };
        Integer[] integers = {1,2,3,4,5,6,7,8,9};
        fun(consumer,integers);
    }
 
 
    public static void fun(Consumer<Integer[]> consumer,Integer[] arr){
        consumer.accept(arr);
    }
}

 2.2 Supplier<T> 供给型函数式接口 无参有返回值

T：返回结果的泛型

该函数式接口的抽象方法为    T   get( );

package FunctionalInterfaceTest;
 
import java.util.function.Supplier;
 
/**
 * @作者：徐志豪
 * @创建时间 2022/7/19 20:22
 * 求数组的和
 * 无参有返回值   供给型
 **/
public class SupplierMethod {
    public static void main(String[] args) {
        Supplier<Integer> supplier = ()->{
            Integer[] integers = {1,2,3,4,5,6,7,8,9};
            Integer sum = 0;
            for (Integer integer : integers) {
                sum+=integer;
            }
            return sum;
        };
        fun(supplier);
    }
 
    public static void fun(Supplier<Integer> supplier){
        Integer integer = supplier.get();
        System.out.println(integer);
    }
}

 2.3 Function<T,R> 函数型函数式接口  有参有返回值

T：参数类型的泛型

R：函数返回结果的泛型

其抽象方法为： R  apply( 参数名 )

package FunctionalInterfaceTest;
 
import java.util.function.Function;
 
/**
 * @作者：徐志豪
 * @创建时间 2022/7/19 20:28
 * 求数组的和/传入一个字符串，返回字符串的长度
 * 有参 有返回值   函数型
 **/
public class FunctionMethod {
    public static void main(String[] args) {
 
        //数组求和
        Function<Integer[],Integer> function = (arr)->{
            Integer sum = 0;
            for (Integer integer : arr) {
                sum+=integer;
            }
            return sum;
        };
        Integer[] arr = {1,2,3,4,5,6,7,8,9};
        fun(function,arr);
 
 
        //计算字符串的长度
        getLength(str->str.length(),"hello lambda");
    }
 
    //数组求和方法
    public static void fun(Function<Integer[],Integer> function,Integer[] arr){
        Integer apply = function.apply(arr);
        System.out.println(apply);
    }
 
    public static void getLength(Function<String,Integer> function,String str){
        Integer apply = function.apply(str);
        System.out.println("该字符串的长度为:"+apply);
    }
}

2.4 Predicated<T>  断言型函数式接口 有参，返回布尔值

T：参数类型的泛型

抽象方法： boolean test(参数名)

例子：判断传入字符串的长度是否大于10 

package FunctionalInterfaceTest;
 
import java.util.function.Predicate;
 
/**
 * @作者：徐志豪
 * @创建时间 2022/7/19 20:31
 * 判断字符串的长度是否大于10
 **/
public class PredicatedMethod {
    public static void main(String[] args) {
        NameIsBigThanThree(name->name.length()>10?true:false,"达拉崩吧版的本地不多秘鲁翁");
    }
 
    public static void NameIsBigThanThree(Predicate<String> predicate,String name){
        boolean test = predicate.test(name);
        System.out.println("该字符串长度大于10是"+test);
    }
}

 三、方法引用

1、lambda表达式的冗余 

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

public class Test01 {
 
    public static void main(String[] args) {
 
        Consumer<Integer[]> c=Test01::sum;
 
        fun(c);
    }
 
 
    public static void fun(Consumer<Integer[]>  consumer){
          Integer[] arr={1,2,3,4,5};
          consumer.accept(arr);
    }
 
    public static void sum(Integer[] arr){
          int sum=0;
          for (int a:arr){
              sum+=a;
          }
        System.out.println("数组的和为:"+sum);
    }
 
}

         请注意其中的双冒号 :: 写法，这被称为“方法引用”，是一种新的语法。

2、 什么是方法引用 

  方法引用的分类：

四种引用方法具体例子： 

2.1 静态方法引用 

类名：：静态方法     代替-->      (参数)->类名.静态方法(参数) 

 对象类型数组或集合的排序：

package referencedByMethodsTest;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
 
/**
 * @作者：徐志豪
 * @创建时间 2022/7/19 20:42
 * 排序
 **/
public class StaticMethodReferencedTest {
    public static void main(String[] args) {
 
        //Person数组
        Person[] ps ={new Person("张三",18),new Person("李四",25),new Person("王五",20),new Person("张三",19)};
        Arrays.sort(ps,Person::compareTo);
        for (Person p : ps) {
            System.out.println(p+"```````数组````````");
        }
 
        //Person集合
        List<Person> list = new ArrayList<>();
        list.add(new Person("张三",51));
        list.add(new Person("李四",35));
        list.add(new Person("王五",27));
        list.add(new Person("赵六",60));
        list.sort(Person::compareTo);
        for (Person person : list) {
            System.out.println(person+"========集合======");
        }
    }
}
 
class Person{
    private String name;
    private Integer age;
 
    public Person() {
    }
 
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    //自定义排序方法
    public static int compareTo(Person o1,Person o2){
        return o2.age - o1.age;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

 2.2  实例方法引用

对象：：实例方法      代替-->      (参数)->对象.实例方法(参数)

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

 例子和静态方法引用里面的例子相同，注意二者的区别

package referencedByMethodsTest;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
/**
 * @作者：徐志豪
 * @创建时间 2022/7/19 21:24
 **/
public class InstanceMethodReferencedTest {
    public static void main(String[] args) {
        //people数组排序
        People[] people = {new People("张三",15),new People("李四",27),new People("王五",19),new People("赵六",35)};
        People people1 = new People();
        //实例方法引用
        Arrays.sort(people,people1::compareTo);
        for (People people2 : people) {
            System.out.println(people2+"------数组排序-----");
        }
 
        //people集合排序
        List<People> list = new ArrayList<>();
        list.add(new People("张三",55));
        list.add(new People("李四",37));
        list.add(new People("王五",68));
        list.add(new People("赵六",25));
        list.sort(people1::compareTo);
        for (People people2 : list) {
            System.out.println(people2+"++++++集合排序++++++");
        }
    }
 
}
 
class People {
    private String name;
    private Integer age;
 
    public People() {
    }
 
    public People(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    //自定义排序方法
    public int compareTo(People o1, People o2){
        return o2.age - o1.age;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

2.3 对象方法引用

类名：：实例方法          代替-->          (参数1，参数2)->参数1.实例方法(参数2)     

package test.methodReference;
 
import java.util.function.BiFunction;
import java.util.function.Function;
 
/**
 * @作者：徐志豪
 * @创建时间 2022/7/20 19:59
 * 对象引用方法     类::实例方法    替换   (参数1，参数2)->参数1.实例方法(参数2)
 **/
public class ObjectReferenceMethod {
    public static void main(String[] args) {
        //比较两个字符串的值是否相等
        //Lambda表达式方法
        BiFunction<String,String,Boolean> function = (t1,t2)->t1.equals(t2);
        Boolean apply = function.apply("hello", "hello");
        System.out.println(apply);
        //对象引用方法
        BiFunction<String,String,Boolean> function1 = String::equals;
        Boolean apply1 = function1.apply("hello", "hello");
        System.out.println(apply1);
 
        //计算字符串的长度
        //lambda表达式
        Function<String,Integer> function2 = (str)->str.length();
        Integer hello_world = function2.apply("hello world");
        System.out.println(hello_world);
        //对象引用方法
        Function<String,Integer> function3 = String::length;
        Integer hello_world1 = function3.apply("hello world");
        System.out.println(hello_world1);
    }
}

 2.4 构造方法引用

类名：：new                 代替-->          (参数)->new 类名(参数)           

package test.methodReference;
 
import java.util.function.BiFunction;
import java.util.function.Function;
 
/**
 * @作者：徐志豪
 * @创建时间 2022/7/20 20:09
 *  构造方法引用   类名::new   替换   (参数)->new  类名(参数)
 **/
public class ConstructorReferenceMethod {
    public static void main(String[] args) {
        //(1) new String
        //Lambda表达式
        Function<String,String> function = (str)->new String(str);
        String hello_world = function.apply("hello world");
        System.out.println(hello_world);
        //构造方法引用
        Function<String,String> function1 = String::new;
        String hello_world1 = function1.apply("hello world");
        System.out.println(hello_world1);
 
 
        //(2) new Person
 
        //lambda表达式
        BiFunction<String,Integer,Person> biFunction = (name,age)->new Person(name,age);
        Person p = biFunction.apply("张三", 18);
        System.out.println(p);
        //构造方法引用
        BiFunction<String,Integer,Person> biFunction1 = Person::new;
        System.out.println(biFunction1.apply("张三",18));
    }
}
class Person{
    private String name;
    private Integer age;
 
    public Person() {
    }
 
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

一个小哑巴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdk1.8新特性——Lambda表达式与函数式接口
can_chen的博客
06-21 833
书到用时方恨少，由于前几日在对接公司的一个项目中，发现该项目用到了很多jdk8的新特性，代码非常的简洁，但是却由于对jdk8的新特性了解甚少，以致很多代码逻辑都看不懂，所以花了些时间学习了jdk8比较重要的几个新特性，并在此进行总结！ Lambda表达式 在java集合中，通过forEach方法遍历集合就用到了jdk1.8的新特性：Lambda表达式与函数式接口 先看forEach方法的源码： default void forEach(Consumer<? super T> action) {
jdk1.8新特性——lambda表达式基础语法
小志的博客
08-24 769
目录一、Lambda 表达式的基础语法二、使用Lambda 表达式的注意事项三、函数式接口的理解四、Lambda 表达式的基础语法示例1、基础语法一：无参数，无返回值2、基础语法二：有一个参数，并且无返回值3、基础语法三：有一个参数，并且无返回值（若只有一个参数，小括号可以省略不写）4、基础语法四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句5、基础语法五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写6、基础语法六： Lambda 表达式的参数列表的数据类型
【JDK1.8 新特性】Lambda表达式
酷奇的博客
03-07 355
只包含一个抽象方法（Single Abstract Method，简称SAM）的接口，称为函数式接口。当然该接口可以包含其他非抽象方法。 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。 我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。 在java.util.f
java8 (jdk 1.8) 新特性——Lambda 以及函数式接口
从零开始的博客
06-16 832
目前已知的是，有个箭头 ->说一大段官方话，也没有任何意义我们直接看代码：之前我们创建线程是这样的初次认识可能会觉得有点离谱，看不懂别急，还有更离谱的很常见的一个例子，比较两个整数的大小之前是这样写的甚至还可以这样 （这个是方法引用）第一个数比第二个数大 ：返回 1小：返回 -1相等：返回 0刚接触是不是黑人问号，这是什么玩意很好，到这，你认识到了lambda 一个缺点，可阅读性差 ，优点 代码简洁小结：看到 -> lambda 看到 : : 方法引用。
jdk1.8 新特性——lambda
逸轩
11-08 239
一、引言 java8最大的特性就是引入Lambda表达式，即函数式编程，可以将行为进行传递。总结就是：使用不可变值与函数，函数对不可变值进行处理，映射成另一个值。 二、java重要的函数式接口 1、什么是函数式接口 函数接口是只有一个抽象方法的接口，用作 Lambda 表达式的类型。使用@FunctionalInterface注解修饰的类，编译器会检测该类是否只有一个抽象方法或接口，否则，...
【java8新特性】——lambda表达式与函数式接口详解（一）
qq_43842093的博客
10-09 762
一、简介 java8于2014年发布，相比于java7，java8新增了非常多的特性，如lambda表达式、函数式接口、方法引用、默认方法、新工具（编译工具）、Stream API、Date Time API、Optional等 。 当前很多公司的老产品依然使用的java7，甚至开发人员开发新产品时依然没有选择升级， 写关于java8系列文章的目的在于梳理和分享java8新增的主要特性，开发时也可以用作参考。 lambda表达式是java8新增的主要特性之一，lambda表达式又称闭包或匿名函数，主要优点在
Java 1.8 新特性—— Lambda 表达式
Lemon
06-28 470
Lambda 表达式也叫函数式编程，Lambda 表达式需要函数式接口的支持，并且接口中的方法只能有一个。 一、函数式编程 1、思想 函数式编程思想：函数就是有有输入量、输出量的一套设计方案 面向对象的思想：做一件事情，去找解决做这间事情的对象，调用方法并完成 2、注意 函数式编程，强调做什么，而不是以什么形式去做 3、函数式接口 只有一个抽象方法的接口，称为函数式接口 可以使用@Fun...
JDK1.8 新特性之Lambda表达式和Stream
时光有伱，记忆成花~
04-13 281
目录 什么是Lambda表达式 Lambda常见写法示例。 为什么要引入Lambda 表达式 什么是函数式接口 自定义一个函数式接口 方法引用 什么是Lambda表达式 Java 8 最大的变化就是引入了Lambda表达式———一种紧凑的、传递行为的方式。 Lambda表达式本质上是一段匿名内部类，也可以是一段可以传递的代码。 可以将Lambda表达式理解为一个匿名函数； La...
【Java】jdk 1.8 新特性——Lambda表达式
面向对象的笔记
04-11 150
Lambda表达式 jdk 1.8 新加入的特性，简化了简单接口的实现 函数式接口 函数式中只有一个待实现的方法，可以使用@FunctionalInterface注解标注函数式接口.这个接口中只能有一个待实现的方法，但可以包含默认方法，静态方法以及Object类中的public方法 package Note.lambda_demo; @FunctionalInterface public int...
jdk1.8系列——8u311-windows-x64.zip
12-27
1. **Lambda表达式**：JDK 1.8引入了Lambda表达式，这是一种简洁的函数式编程语法，使得编写匿名函数更加简单。通过这种方式，开发者可以使用更少的代码实现功能，提高代码可读性和效率。 2. **Stream API**：...
JDK1.8安装包（windowsx64）
08-04
1. **lambda表达式**：Java 8引入了函数式编程的核心元素——lambda表达式，使得代码更加简洁，尤其在处理集合操作时，通过Stream API和lambda可以写出非常优雅的代码。 2. **方法引用和构造器引用**：这是与lambda...
jdk1.8——Java开发环境（最常用）
10-17
**JDK1.8——Java开发环境（最常用）** JDK（Java Development Kit）是Oracle公司提供的Java编程工具包，用于开发、编译、调试Java应用程序。JDK1.8，也称为Java 8，是Java历史上一个非常重要的版本，它的发布在...
Java——jdk1.8(64位和32位)
11-12
这个版本在2014年发布，引入了许多新特性，如lambda表达式、流API（Stream API）、新的日期和时间API等。 2. **JDK与JRE**：JDK（Java Development Kit）是Java开发人员所需的完整工具集，包括JRE（Java Runtime ...
java——jdk1.8
04-03
4. **Java版本**：JDK 1.8引入了许多新特性，包括Lambda表达式、方法引用来简化代码，Stream API增强集合操作，以及Date和Time API的改进。Lambda表达式允许开发者以更简洁的方式处理函数式编程，而Stream API则提供...
GitHub 详解教程
m0_46566693的博客
07-24 2749
GitHub 详解教程
Github 2024-07-22开源项目日报Top10
老孙正经胡说
07-22 1188
根据Github Trendings的统计，今日(2024-07-22统计)共有10个项目上榜。
Github 2024-07-25开源项目日报 Top10
老孙正经胡说
07-25 968
根据Github Trendings的统计，今日(2024-07-25统计)共有10个项目上榜。
day14Git、GitHub与GitLab简介
最新发布
2301_81313780的博客
07-25 1088
在DVCS中，每个客户端同时充当服务器的角色，拥有自己的代码库和历史记录，允许独立工作和多分支开发。d="当前主机内存信息 总内存： ${g}${total} MB${e} 当前已用： ${g}${used} MB${e} 当前可用： ${g}${free} MB${e} 共享占用： ${g}${shared} MB${e} 缓存占用： ${g}${cache} MB${e}"echo -e " ${g} # ${e} \t\033[33m1. 剪刀 \033[0m\t\t\t ${g} # ${e} "
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值