JAVA8核心语法梳理（1）Lambda表达式、函数式接口、方法引用

最新推荐文章于 2024-08-09 08:31:16 发布
最新推荐文章于 2024-08-09 08:31:16 发布
阅读量301 收藏 2
点赞数
分类专栏： 【JAVA】综合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshixuye/article/details/108671951
版权

欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，同时欢迎大家加我微信「java_front」一起交流学习

1 文章概述

JAVA13已经面世一段时间了，但是追根溯源一些新特性例如Lambda表达式、函数式接口、StreamAPI首次还在是出现在JAVA8。这些新特性有些开发者使用并不习惯，尤其链式编程感觉没有代码断句，可读性不强。但是JAVA8之所以逐渐流行确实是因为确实有许多优点：

  • 代码优雅
  • 易于并行
  • StreamAPI
  • Optional减少空指针

现在项目代码中越来越多出现JAVA8语法，为了读懂代码也需要我们熟悉JAVA8语法，本文介绍JAVA8如下重要特性，streamAPI我们下一篇文章再详细介绍。

  • Lambda表达式
  • 函数式接口
  • 方法引用

2 Lambda表达式

2.1 基本说明

Lambda表达式本质上是一个匿名函数，我们可以将一个Lambda表达式像参数一样进行传递。

public static void test01() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("公众号JAVA前线");
        }
    }).start();

    /** Lambda表达式 **/
    new Thread(() -> System.out.println("公众号JAVA前线")).start();
}

我们看到Lambda表达式6行代码缩短为1行，代码简洁而优雅，但是仅仅看代码并不好理解，下面我们介绍Lambda语法。

2.2 语法详解

Lambda表达式引入了->箭头操作符，箭头操作符左边指定表达式参数，右表是表达式执行体，下面我们根据参数个数的不同说明Lambda表达式语法。

(1) 无参数
public static void test02_NoParam() {
    Runnable task = () -> System.out.println("公众号JAVA前线");
    new Thread(task).start();
}
(2) 一个参数

单个参数可以不写小括号。假设一个方法参数类是字符串，在写Lambda表达式时并不要显示申明String类型，编译器可以根据上下文推断出类型，这就是类型推断。

import java.util.function.Consumer;

public static void test03_OneParam() {
    Consumer<String> c1 = (str) -> System.out.println(str);
    c1.accept("公众号JAVA前线");
    Consumer<String> c2 = str -> System.out.println(str);
    c2.accept("公众号JAVA前线");
}

上述例子使用了函数式接口Consumer我们后面再讲。

(3) 多个参数

如果Lambda体只有一行代码则花括号和return可以省略

public class Student {
    private int age;
    private String name;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

public static void test04_MultiParam() {
    List<Student> list = new ArrayList<Student>();
    Collections.sort(list, new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getAge().compareTo(o2.getAge());
        }
    });
    Collections.sort(list, (o1, o2) -> {
        return o1.getAge().compareTo(o2.getAge());
    });
    Collections.sort(list, (o1, o2) -> o1.getAge().compareTo(o2.getAge()));
}

3 函数式接口

函数式接口特点只包含了一个方法。JAVA8有四大内置函数式接口，其它内置函数式接口，还可以自定义函数式接口。

3.1 四大内置函数式接口

接口名输入类型输出类型核心方法说明
Consumer[T]Tvoidaccept(T)消费型
Supplier[T]voidTT get()供给型
Function[T,R]TRR apply(T)函数型
Predicate[T]Tbooleanboolean test(T)判断型
(1) Consumer

Consumer作为消费型接口输入类型为T，没有输出类型

import java.util.function.Consumer;

public static void testConsumer() {
    Consumer<String> consumer = (str) -> {
        String newStr = "公众号" + str;
        System.out.println(newStr);
    };
    consumer.accept("JAVA前线");
}
(2) Supplier

Supplier作为供给型接口没有输入类型，输出类型为T

import java.util.function.Supplier;

public static void testSupplier() {
    Supplier<String> supplier = () -> {
        return "公众号JAVA前线";
    };
    String result = supplier.get();
    System.out.println(result);
}
(3) Function

Function作为函数型接口输入类型为T，输出类型为R

import java.util.function.Function;

public static void testFunction() {
    Function<String, Integer> function = (str) -> {
        if("公众号JAVA前线".equals(str)) {
            return 1;
        }
        return 0;
    };
    Integer result = function.apply("公众号JAVA前线");
    System.out.println(result);
}
(4) Predicate

Predicate作为判断型接口输入类型为T，输出类型为Boolean

import java.util.function.Predicate;

public static void testPredicate() {
    Predicate<String> predicate = (str) -> {
        if ("公众号JAVA前线".equals(str)) {
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    };
    boolean result = predicate.test("公众号JAVA前线");
    System.out.println(result);
}
3.2 自定义函数接口

FunctionalInterface标识一个自定义函数式接口，我们可以根据需求定义功能强大的函数接口

/**
 * 自定义函数接口
 *
 * @author 公众号JAVA前线
 *
 * @param <T> 输入类型1
 * @param <R> 输入类型2
 * @param <U> 输出类型
 */
@FunctionalInterface
public interface MyInterfaceFunction<T, R, U> {
    public U bizMethod(T t, R r);
}

/**
 * 测试实例
 */
public class Java8_Function {
    public static void testMyFunction() {
        MyInterfaceFunction<String, String, Integer> myFuntion = (str1, str2) -> {
            if ("公众号".equals(str1) && "JAVA前线".equals(str2)) {
                return 1;
            }
            return 0;
        };
        Integer result = myFuntion.bizMethod("公众号", "JAVA前线");
        System.out.println(result);
    }
}
3.3 其它内置函数式接口

在四大内置函数式接口基础上，JAVA8提供了其它内置函数式接口，我们尝试列出一些并选择编写几个代码实例。

接口名输入类型输出类型核心方法
BiConsumer[T,U]T、Uvoidaccept(T,U)
BiFunction[T,U,R]T、URR apply(T,U)
UnaryOperator[T]TTT apply(T)
BinaryOperator[T]T、TTT apply(T,T)
ToIntFunction[T]Tintint apply(T)
(1) BiFunction

BiFunction是Function函数增强版，允许两种输入类型

import java.util.function.BiFunction;

public static void testBiFunction() {
    BiFunction<String, String, Integer> biFunction = (str1, str2) -> {
        if ("公众号".equals(str1) && "JAVA前线".equals(str2)) {
            return 1;
        }
        return 0;
    };
    Integer result = biFunction.apply("公众号", "JAVA前线");
    System.out.println(result);
}
(2) BiConsumer

BiConsumer是Consumer函数增强版本，允许两种输入类型

import java.util.function.BiConsumer;

public static void testBiConsumer() {
    BiConsumer<String, String> biConsumer = (str1, str2) -> {
        System.out.println(str1 + str2);
    };
    biConsumer.accept("公众号", "JAVA前线");
}
(3) BinaryOperator

对类型为T的数据进行二元运算，并返回类型为T的结果

import java.util.function.BinaryOperator;

public static void testBinaryOperator() {
    BinaryOperator<String> biOperator = (str1, str2) -> {
        return str1 + str2;
    };
    String result = biOperator.apply("公众号", "JAVA前线");
    System.out.println(result);
}

4 方法引用

方法引用语法操作符是两个冒号，初看会让人比较费解。本章节我们来分析这个语法。当我们在编写Lambda方法体时，如果方法体的方法已经有现成实现，那么我们可以直接引用这个方法，这就是方法引用，需要注意的是参数列表必须一致。方法引用语法有四类：

  • 对象::实例方法
  • 类::静态方法
  • 类::实例方法
  • 类::new

4.1 对象::实例方法

public class Student {
    private String name;

    public String getName() {
        return name;
    }

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

public static void test01() {
    Consumer<String> c1 = (x) -> System.out.println(x);
    c1.accept("公众号JAVA前线");

    Consumer<String> c2 = System.out::println;
    c2.accept("公众号JAVA前线");

    Student student = new Student("公众号JAVA前线");
    Supplier<String> s1 = () -> student.getName();
    System.out.println(s1.get());

    Supplier<String> s2 = student::getName;
    System.out.println(s2.get());
}

4.2 类::实例方法

public class Student {
    private int age;
    private String name;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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


public static void test02() {
    BiPredicate<String, String> bp1 = (x, y) -> x.equals(y);
    System.out.println(bp1.test("公众号", "JAVA前线"));
    // 类::实例方法
    BiPredicate<String, String> bp2 = String::equals;
    System.out.println(bp2.test("公众号", "JAVA前线"));

    List<Student> list = new ArrayList<Student>();
    Collections.sort(list, new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getAge().compareTo(o2.getAge());
        }
    });
    Collections.sort(list, (o1, o2) -> o1.getAge().compareTo(o2.getAge()));
    // 类::实例方法
    Collections.sort(list, Comparator.comparing(Student::getAge));
}

4.3 类::静态方法

public class Student {

    private int age;
    private String name;

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public static int compareAge(Student s1, Student s2) {
        return s1.getAge().compareTo(s2.getAge());
    }
}

public static void test03() {
    List<Student> list = new ArrayList<Student>();
    Collections.sort(list, new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getAge().compareTo(o2.getAge());
        }
    });
    Collections.sort(list, (o1, o2) -> o1.getAge().compareTo(o2.getAge()));
    Collections.sort(list, Comparator.comparing(Student::getAge));
    // 类::静态方法
    Collections.sort(list, Student::compareAge);
}

4.4 类::new

public class Student {
    private String name;

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

public static void test04() {
    Function<String, Student> f1 = (str) -> new Student(str);
    System.out.println(f1.apply("公众号JAVA前线"));

    Function<String, Student> f2 = Student::new;
    System.out.println(f2.apply("公众号JAVA前线"));

    Function<Integer, Integer[]> f3 = (num) -> new Integer[num];
    System.out.println(f3.apply(15));

    Function<Integer, Integer[]> f4 = Integer[]::new;
    System.out.println(f4.apply(15));

    Supplier<List<Student>> s1 = () -> new ArrayList<Student>();
    System.out.println(s1.get());

    Supplier<List<Student>> s2 = ArrayList<Student>::new;
    System.out.println(s2.get());
}

5 文章总结

本文我们总结了Lambda表达式，函数式接口，方法引用语法，这些语法相较于传统语法改变不小，一开始并不容易理解，还需要反复实践。下一篇文章我们介绍JAVA8强大的StreamAPI语法请继续关注。

欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，同时欢迎大家加我微信「java_front」一起交流学习

在这里插入图片描述

JAVA前线
关注
专栏目录
Java 新特性：Lambda 表达式
栗筝i的博客
08-18 407
Lambda 表达式（Lambda expression），也可称为闭包（Closure），是 Java（SE）8 中一个重要的新特性。Lambda 表达式允许我们通过表达式来代替功能接口。Lambda 表达式就和方法一样，它提供了一个正常的参数列表和一个使用这些参数的主体（body，可以是一个表达式或一个代码块）Lambda 表达式可以看作是一个匿名函数，基于数学中的 λ 演算得名。如果说，⼀个接口中，要求实现类必须实现的抽象方法，有且只有⼀个！这样的接口，就是函数式接口。
聊聊Java8中的函数式编程
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
08-08 1045
因为是Predicate是函数式接口，其抽象方法只有唯一一个test，所以我们的参数列表即使不指明类型，它也能够通过类型推断机制得出参数类型，所以我们可以直接将参数类型简写为s。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。由于函数式接口的理念，保证了行为抽象和实现上的便利，大量的开源项目都运用到了函数式编程风格，最经典的就是。语法，首先我们根据Predicate的抽象接口得出，它要求传入一个T类型，以我们的代码为例就是。
Java8语法总结
06-04
学习java8新特性，尤其是lambda和流式编程，学习过程中总结的笔记
Java8-表达式语法
muyekaola的博客
12-10 193
语法 Lambda 表达式在Java 语言中引入了一个新的语法元 素和操作符。这个操作符为 “->” ， 该操作符被称 为 Lambda 操作符或剪头操作符。它将 Lambda 分为 两个部分： 左侧：指定了 Lambda 表达式需要的所有参数 右侧：指定了 Lambda 体，即 Lambda 表达式要执行 的功能。 语法格式 语法格式一：无参，无返回值，Lambda体只需一条语句 旧写法： Runnable runnable = new Runnable() { int n
java8新语法
weixin_30550081的博客
03-22 141
Lambda表达式和函数接口（Functional Interface） 1 // lambda expressions 2 public static void DemoLambda() { 3 // 不使用lambda表达式 4 Runnable runnable1 = new Runnable() { 5 ...
Java进阶知识笔记13--【Stream流、方法引用】
Kuber
10-09 432
【Stream流、方法引用】 主要内容 Stream流 方法引用 第一章 Stream流 说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带 来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 1.1 引言 传统集合的多步遍历代码 几乎所有的集合（如Collection 接口或Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，
java8语法
qq_28764557的博客
02-03 128
1.filter 集合的filter，里面传的是集合的一个元素。 ------------------------------------------------------------------------------------------- 2.anyMatch 也是集合的一个元素 ---------------------------------------------...
聊聊java8的方法引用结合lambda最佳实践
最新发布
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
08-09 1163
我们再来一个难一点的例子，假设我们的现在的类有重量和颜色两种属性，并指明使用全参构造器完成实例创建，我们如何将这个构造器转换为方法引用呢？因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。做一些实用的拓展，先来说说复合比较器，以上文的苹果为例，假设我们希望当重量一样时，在比较颜色进行进一步比较，那么我们就可以直接通过。因为重量单位的不同，所以得出的重量的结果可能是不同的，所以我们将计算重量的核心部分抽象成函数式接口，如下。
Java 关于抽象 -- Java 语言的抽象类、接口和函数式接口
栗筝i的博客
06-12 2510
在理解了 Java 的基础语法和面向对象编程概念之后，本篇文章将进一步探讨 Java 中的抽象机制。我们将讨论抽象类与接口的区别和使用场景，了解函数式接口在 Java 8 中的引入及其重要性。通过掌握这些高级概念，读者将能够编写出更灵活和可维护的代码。
Java 基础 —— Lambda 表达式
MichaelHH
07-08 288
概述 阅读项目代码时，尤其是阅读一些源码时，经常会遇到 Lambda 表达式。对此之前看过相关文章，但是停留在模模糊糊的印象上。今天趁着有时间，通过一些 demo 示例，梳理一下它的用法，以备后期遗忘的时候快速查询它的用法！ Lambda 表达式是 Java 8 的重要更新，它支持将代码块作为方法参数、允许使用更简洁的代码来创建只有一个抽象方法的接口的实例。 描述中提到的接口称为函数...
java8 语法
qq_43040552的博客
06-19 224
// 1. Lambda 表达式 java.util.function.* { // 提供者 Supplier supplier = () -> 5; // 消费者 Consumer consumer = (Integer a) -> System.out.println(a); // 消费者（缩写） Consumer consumer2 = a -> System.out.p...
Java8 语法
牧小七的博客
06-04 132
Lambda表达式允许我们以更紧凑的方式编写代码，尤其是在需要实现函数式接口时。它提供了一种简单而强大的方式来对数据进行筛选、排序、映射等操作。方法引用是一种更简洁的Lambda表达式形式，可以将方法作为参数传递，从而避免重复编写相同的代码。这只是Java8中一些常用的语法，还有很多其他的新特性和语法需要我们去探索和学习。默认方法是接口中的一种新特性，它允许在不破坏现有代码的情况下向接口添加新方法。Java8引入了一套全新的时间API，它提供了一种更好的方式来处理日期和时间。
Java 8语法学习
Cheng_913的博客
09-20 254
1. Lambda表达式 2. 方法引用与构造器引用 3. Stream API 4. Optional类 5. 时间处理
java8基础语法
五宝茶四娃的博客
08-03 418
java8基础语法。
Java8 常用语法
qq_41228643的博客
07-10 409
常用语法收录 stuList.add(new Stu(11,"1","男","2021-12-12 11:22:22")); stuList.add(new Stu(12,"2","男","2020-12-11 11:22:22")); stuList.add(new Stu(16,"3","男","2019-10-12 11:22:22")); stuList.add(new Stu(19,"4","男","2018-12-10 11:22:
java 8 语法_Java8新特性，语法学习
weixin_28913687的博客
02-16 138
package com.example.demo.java8;import com.example.demo.domin.User;import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.stream.Collectors;import java.util.stream.In...
JAVA8 Lambda 语法学习
itheimach的专栏
10-02 429
在 Java 世界中，匿名内部类 可以实现在应用程序中可能只执行一次的操作。例如，在 Android点击事件中,可以用匿名内部类完成该操作：Button button = (Button) findViewById(R.id.button1); button.setOnClickListener(new OnClickListener() { @Override public void
Java 8新特性详解：Lambda表达式与函数式接口深度解析
Java 8的新特性是编程语言发展的一个重要里程碑，它引入了Lambda表达式和函数式编程的概念，使得代码更加简洁、灵活和高效。以下是对这些新特性的详细解析： 1. **Lambda表达式** - **概念**：Lambda表达式是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值