Java Lambda表达式常用的函数式接口

目录
  • Supplier接口
  • Consumer接口
  • Predicate接口
  • Function接口
  • BiFunction接口
  • 基本数据类型
  • Supplier相关的接口
  • Consumer相关的接口
  • Predicate相关的接口
  • Function相关的接口

前言:

在Java8支持Lambda表达式以后,为了满足Lambda表达式的一些典型使用场景,JDK为我们提供了大量常用的函数式接口。它们主要在 java.util.function 包中,下面简单介绍几个其中的接口及其使用示例。

Supplier接口

Supplier接口是对象实例的提供者,定义了一个名叫get的抽象方法,它没有任何入参,并返回一个泛型T对象,具体源码如下:

package java.util.function;

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

源码比较简单,我们来个例子。这是之前提过的表示口罩的类:

package one.more.study;

/**
 * 口罩
 */
public class Mask {
    public Mask(String brand, String type) {
        this.brand = brand;
        this.type = type;
    }
    /**
     * 品牌
     */
    private String brand;
    /**
     * 类型
     */
    private String type;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

下面我们使用Lambda表达式声明一个Supplier的实例:

Supplier<Mask> supplier = () -> new Mask("3M", "N95");

用它来创建品牌为3M、类型为N95的Mask实例:

Mask mask = supplier.get();
System.out.println("Brand: " + mask.getBrand() + ", Type: " + mask.getType());

运行结果如下:

Brand: 3M, Type: N95

特别需要注意的是,本例中每一次调用get方法都会创建新的对象。

Consumer接口

Consumer接口是一个类似消费者的接口,定义了一个名叫accept的抽象方法,它的入参是一个泛型T对象,没有任何返回(void),主要源码如下:

package java.util.function;

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

结合上面的Supplier接口,我们来个例子:

Supplier<Mask> supplier = () -> new Mask("3M", "N95");
Consumer<Mask> consumer = (Mask mask) -> {
    System.out.println("Brand: " + mask.getBrand() + ", Type: " + mask.getType());
};
consumer.accept(supplier.get());

首先使用Lambda表达式声明一个Supplier的实例,它是用来创建品牌为3M、类型为N95的Mask实例;再使用Lambda表达式声明一个Consumer的实例,它是用于打印出Mask实例的相关信息;最后Consumer消费了Supplier生产的Mask

运行结果如下:

Brand: 3M, Type: N95

Predicate接口

Predicate接口是判断是与否的接口,定义了一个名叫test的抽象方法,它的入参是一个泛型T对象,并返回一个boolean类型,主要源码如下:

package java.util.function;

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

结合上面的Supplier接口,我们来个例子:

Supplier<Mask> supplier = () -> new Mask("3M", "N95");
Predicate<Mask> n95 = (Mask mask) -> "N95".equals(mask.getType());
Predicate<Mask> kn95 = (Mask mask) -> "KN95".equals(mask.getType());
System.out.println("是否为N95口罩:" + n95.test(supplier.get()));
System.out.println("是否为KN95口罩:" + kn95.test(supplier.get()));

首先使用Lambda表达式声明一个Supplier的实例,它是用来创建品牌为3M、类型为N95的Mask实例;再使用Lambda表达式声明一个Predicate的实例n95,它是用于判断是否为N95口罩;再使用Lambda表达式声明一个Predicate的实例kn95,它是用于判断是否为KN95口罩;最后分别用两个Predicate判断Supplier生产的Mask

运行结果如下:

是否为N95口罩:true
是否为KN95口罩:false

Function接口

Function接口是对实例进行处理转换的接口,定义了一个名叫apply的抽象方法,它的入参是一个泛型T对象,并返回一个泛型R对象,主要源码如下:

package java.util.function;

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

结合上面的Supplier接口,我们来个例子:

Supplier<Mask> supplier = () -> new Mask("3M", "N95");
Function<Mask, String> brand = (Mask mask) -> mask.getBrand();
Function<Mask, String> type = (Mask mask) -> mask.getType();
System.out.println("口罩品牌:" + brand.apply(supplier.get()));
System.out.println("口罩类型:" + type.apply(supplier.get()));

首先使用Lambda表达式声明一个Supplier的实例,它是用来创建品牌为3M、类型为N95的Mask实例;再使用Lambda表达式声明一个Function的实例brand,它是用于获取口罩的品牌;再使用Lambda表达式声明一个Function的实例type,它是用于获取口罩的类型;最后分别用两个Function分析Supplier生产的Mask

运行结果如下:

口罩品牌:3M
口罩类型:N95

BiFunction接口

Function接口的入参只有一个泛型对象,JDK还为我们提供了两个泛型对象入参的接口:BiFunction接口,主要源码如下:

package java.util.function;

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}

我们可以用BiFunction接口传入两个String直接创建Mask实例:

BiFunction<String,String,Mask> biFunction = (String brand, String type) -> new Mask(brand, type);
Mask mask = biFunction.apply("3M", "N95");
System.out.println("Brand: " + mask.getBrand() + ", Type: " + mask.getType());

运行结果如下:

Brand: 3M, Type: N95

基本数据类型

以上介绍的几个常用的函数式接口入参和返回,都是泛型对象的,也就是必须为引用类型。当我们传入或获取的是基本数据类型时,将会发生自动装箱和自动拆箱,带来不必要的性能损耗,比如:

Supplier&lt;Long&gt; supplier = () -&gt; System.currentTimeMillis();
long timeMillis = supplier.get();

在上面例子里,发生了一次自动装箱(long被装箱为Long)和一次自动拆箱(Long被拆箱为long),如何避免这种不必要的性能损耗呢?JDK为我们提供相应的函数式接口,如LongSupplier接口,定义了一个名叫getAsLong的抽象方法,签名是() -> long

上面的例子可以优化为:

LongSupplier supplier = () -&gt; System.currentTimeMillis();
long timeMillis = supplier.getAsLong();

类似这样的接口还有很多,我为大家整理了一下:

Supplier相关的接口

接口名称 方法名称 方法签名
Supplier get () -> T
BooleanSupplier getAsBoolean () -> boolean
DoubleSupplier getAsDouble () -> double
IntSupplier getAsInt () -> int
LongSupplier getAsLong () -> long

Consumer相关的接口

接口名称 方法名称 方法签名
Consumer accept (T) -> void
DoubleConsumer accept (double) -> void
IntConsumer accept (int) -> void
LongConsumer accept (long) -> void
ObjDoubleConsumer accept (T, double) -> void
ObjIntConsumer accept (T, int) -> void
ObjLongConsumer accept (T, long) -> void

Predicate相关的接口

接口名称 方法名称 方法签名
Predicate test (T) -> boolean
BiPredicate test (T, U) -> boolean
DoublePredicate test (double) -> boolean
IntPredicate test (int) -> boolean
LongPredicate test (long) -> boolean

Function相关的接口

接口名称 方法名称 方法签名
Function apply (T) -> R
BiFunction apply (T, U) -> R
DoubleFunction apply (double) -> R
DoubleToIntFunction applyAsInt (double) -> int
DoubleToLongFunction applyAsLong (double) -> long
IntFunction apply (int) -> R
IntToDoubleFunction applyAsDouble (int) -> double
IntToLongFunction applyAsLong (int) -> long
LongFunction apply (long) -> R
LongToDoubleFunction applyAsDouble (long) -> double
LongToIntFunction applyAsInt (long) -> int
ToDoubleFunction applyAsDouble (T) -> double
ToDoubleBiFunction applyAsDouble (T, U) -> double
ToIntFunction applyAsInt (T) -> int
ToIntBiFunction applyAsInt (T, U) -> int
ToLongFunction applyAsLong (T) -> long
ToLongBiFunction applyAsLong (T, U) -> long

到此这篇关于Java Lambda表达式常用的函数式接口的文章就介绍到这了,更多相关Lambda函数式接口内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java中常用的Lambda表达式案例解析

    目录 1.ForEach 2.Collect 3.Filter 4.Map 5.MapToInt 6.Distinct 7.Sorted 8.groupingBy 9.FindFirst 10.Reduce 11.Peek 12.Limit 13.Max,Min 总结 前言: 我们日常工作中,Lambda 使用比较多的场景,就是集合类下的 Lambda 流操作,往往几行代码可以帮助我们实现复杂代码 接下来我们把 Lambda 流的常用方法用案列讲解一下. 1.ForEach 集合的遍历forEa

  • Java中Lambda表达式用法介绍

    Lambda lambda是一个匿名函数,我们可以把lambda表达式理解为是一段可以传递的代码. lambda简明的地将代码或方法作为参数传递进去执行. "函数式编程"其核心是把函数作为值. 函数式接口 :只有一个 抽象方法的接口 称之为 函数式接口.函数式接口可以使用@FunctionalInterface进行注解. lambda表达式拆分为两部分 左侧:lambda 表达式的参数列表 右侧:lambda 表达式中所需要执行的功能,即lambda体 语法格式一:无参数,无返回值 @

  • 深入浅出理解Java Lambda表达式之四大核心函数式的用法与范例

    目录 1.四大核心函数式接口 1.1 Consumer<T> : 消费型接口 1.2 Supplier<T> : 供给型接口 1.3 Function<T, R> : 函数型接口 1.4 Predicate<T> : 断言型接口 2.方法引用 2.1 对象 :: 实例方法 2.2 类 :: 静态方法 2.3 类 :: 实例方法 3.构造器引用 4.数组引用 1.四大核心函数式接口 上一篇文章中说到了Lambda表达式中的基本语法,以及我们如何自定义函数式接口

  • JAVALambda表达式与函数式接口详解

    Lambda表达式的诞生是为了解决JAVA创建匿名内部类代码冗余的问题.例子如下: public class Lambda { public static void main(String[] args) { Gog gog = new Gog() { @Override public void say() { System.out.println("WOW"); } }; gog.say(); } } interface Gog { void say(); } 这里我们想实现接口的s

  • Java Lambda表达式超详细介绍

    目录 一.背景 1.Lambda表达式的语法 2.函数式接口 二.Lambda表达式的基本使用 三.语法精简 四.变量捕获 五.Lambda在集合当中的使用 1.Collection接口 六.List接口 1.sort()方法的演示 七.Map接口 一.背景 Lambda表达式是Java SE 8中一个重要的新特性.lambda表达式允许你通过表达式来代替功能接口. lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块). L

  • 一起来了解Java的Lambda表达式

    目录 Lambda表达式: 1.简介 2.Lambda表达式的使用: 1.在普通方法内的使用 2.带参方法的使用 3.Lambda表达式实现多线程 4.Lambda表达式操作运算 5.Lambda表达式方法引用 6.Lambda表达式对集合的使用 7.总结 Lambda表达式: 1.简介 首先Lambda表达式是属于Java8的 一个新特性,提供Java编程中对于函数式编程的支持,有助于代码的简洁,可以取代大半部分的匿名函数,尤其对于集合的遍历和集合的操作,极大的简化了代码. Lambda表达式

  • 关于Java 中的 Lambda 表达式

    这篇文章我们将讨论关于Java 中的 Lambda 表达式,Lambda 表达式是 Java 涉足函数式编程的过程.它接受参数并将其应用于表达式或代码块.以下是语法的基本示例: (parameter1, parameter2) => expression 或者 (parameter1, parameter2) => {code block} Lambda 表达式非常有限,如果它不是 void,则必须立即返回一个值.他们不能使用诸如 if 或 for 之类的关键字来保持简单性.如果需要更多行代码

  • Java 进阶使用 Lambda 表达式实现超强的排序功能

    目录 基于Comparator排序 使用 Lambda 表达式替换Comparator匿名内部类 通过静态方法抽取公共的 Lambda 表达式 借助Comparator的comparing方法 多条件排序 在Stream中进行排序 倒序排列 调转排序判断 在Comparator.comparing中定义排序反转 在Stream中定义排序反转 null 值的判断 元素是 null 的笨拙实现 排序条件的字段是 null 文末总结 我们在系统开发过程中,对数据排序是很常见的场景.一般来说,我们可以采

  • Java Lambda表达式常用的函数式接口

    目录 Supplier接口 Consumer接口 Predicate接口 Function接口 BiFunction接口 基本数据类型 Supplier相关的接口 Consumer相关的接口 Predicate相关的接口 Function相关的接口 前言: 在Java8支持Lambda表达式以后,为了满足Lambda表达式的一些典型使用场景,JDK为我们提供了大量常用的函数式接口.它们主要在 java.util.function 包中,下面简单介绍几个其中的接口及其使用示例. Supplier接

  • Java Lambda表达式常用的函数式接口

    失去人性,失去很多:失去兽性,失去一切.——<三体> 在Java8支持Lambda表达式以后,为了满足Lambda表达式的一些典型使用场景,JDK为我们提供了大量常用的函数式接口.它们主要在 java.util.function 包中,下面简单介绍几个其中的接口及其使用示例. Supplier接口 Supplier接口是对象实例的提供者,定义了一个名叫get的抽象方法,它没有任何入参,并返回一个泛型T对象,具体源码如下: package java.util.function; @Functio

  • Java Lambda表达式和函数式接口实例分析

    本文实例讲述了Java Lambda表达式和函数式接口.分享给大家供大家参考,具体如下: 一 点睛 Lambda表达式的类型,也称为"目标类型",Lambda表达式的目标类型必须是函数式接口.函数式接口代表只包含一个抽象方法的接口.函数式接口可以包含多个默认方法.类方法,但只能声明一个抽象方法. 如果采用匿名内部类语法来创建函数式接口的实例,只要实现一个抽象方法即可,在这种情况下即可采用Lambda表达式来创建对象,该表达式创建出来的对象的目标类型就是这个函数式接口. Java 8专门

  • Java Lambda表达式与匿名内部类的联系和区别实例分析

    本文实例讲述了Java Lambda表达式与匿名内部类的联系和区别.分享给大家供大家参考,具体如下: 一 点睛 Lambda表达式与匿名内部类存在如下相同点: Lambda表达式与匿名内部类一样,都可以直接访问"effectively final"的局部变量,以及外部类的成员变量(包括实例变量和类变量). Lambda表达式创建的对象与匿名内部类生成的对象一样, 都可以直接调用从接口继承得到的默认方法. Lambda表达式与匿名内部类主要存在如下区别: 匿名内部类可以为任意接口创建实例

  • Java Lambda 表达式详解及示例代码

    Java Lambda 表达式是 Java 8 引入的一个新的功能,可以说是模拟函数式编程的一个语法糖,类似于 Javascript 中的闭包,但又有些不同,主要目的是提供一个函数化的语法来简化我们的编码. Lambda 基本语法 Lambda 的基本结构为 (arguments) -> body,有如下几种情况: 参数类型可推导时,不需要指定类型,如 (a) -> System.out.println(a) 当只有一个参数且类型可推导时,不强制写 (), 如 a -> System.o

  • Java lambda表达式与泛型整理总结

    目录 泛型 泛型的语法定义 泛型的使用语法 泛型总结 从泛型类派生子类 泛型接口 lambda表达式 lambda表达式概念 lambda表达式格式 泛型 泛型的语法定义 class 类名 <泛型标识,泛型标识,…>{ private 泛型标识1,变量名:常用的泛型标识:T,E,K,V } 里面正常写法 public class GenericDemo<K> { //定义数组 private K[] arr; } 泛型的使用语法 类名<具体的数据> 对象名 = new

  • Java Lambda表达式入门示例

    本文实例讲述了Java Lambda表达式.分享给大家供大家参考,具体如下: 一 点睛 Lambda表达式支持将代码块作为方法参数,Lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口(函数式接口)的实例. Lambda表达式主要作用就是代替匿名内部类的繁琐语法. 它由三部分组成: 形参列表.形参列表允许省略形参类型.如果形参列表中只有一个参数,甚至连形参列表的圆括号也可以省略. 箭头(->),必须通过英文等号和大于符号组成. 代码块.如果代码块只有包含一条语句,Lambda表达式

  • Java Lambda表达式的方法引用和构造器引用实例分析

    本文实例讲述了Java Lambda表达式的方法引用和构造器引用.分享给大家供大家参考,具体如下: 一 点睛 如果Lambda表达式的代码块只有一条代码,还可以在代码块中使用方法引用和构造器引用,以使得Lambda表达式更加简洁. 种类 示例 说明 对应的Lambda表达式 引用类方法 类名::类方法 函数式接口中被实现方法的全部参数传给该类方法作为参数. (a,b,...) -> 类名.类方法(a,b, ...) 引用特定对象的实例方法 特定对象::实例方法 函数式接口中被实现方法的全部参数传

  • 详细分析Java Lambda表达式

    在了解Lambda表达式之前我们先来区分一下面向对象的思想和函数式编程思想的区别 面向对象的思想: 做一件事情,找一个能解决这个事情的对象,调用他的方法来解决 函数时编程思想: 只要能获取到结果,谁去做的都不重要,重视的是结果,不重视过程 使用Lambda表达式的目的是为了简化我们的代码 匿名内部类虽然也简化了我们的代码,但是Lambda比他更简单,而且语法也更加少 下面我用一段代码来演示一下二者的区别 public class Main { public static void main(St

随机推荐