java8中的lambda接口Consumer,Function,BiConsumer,BiFunction

最新推荐文章于 2023-08-08 10:22:22 发布
最新推荐文章于 2023-08-08 10:22:22 发布
阅读量1.6k 收藏 4
点赞数 1
分类专栏： lambda 文章标签： java lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xby7437/article/details/112235579
版权

简介

在java8中新增lambda表达式，平时我们用的也比较多，主要用于替代匿名内部类，使代码更加的优雅简洁。最近在看spring源码时，发现内部用到的也非常多。虽然我们大部分用的都是stream，但是其中也涉及到非常多的函数式接口，比如Consumer,Function,BiConsumer,BiFunction等等。所以今天就梳理下java8中的一些函数式接口。

函数式接口

在说lambda之前，先解释下什么是函数式接口。函数式接口指的是有且只有一个抽象方法。由于java8支持接口实现默认方法，有一个抽象方法，很多个默认方法也是函数式接口。并且java8还提供了函数式接口的注解@FunctionalInterface，用来表示这是一个函数式接口。比如jdk自带的Consumer接口，他就是一个accept抽象方法，和一个andThen的默认方法。关于默认方法就是可以不去实现，直接使用。

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }

}

使用

Consumer

consumer的接口上面已经展示过了，但是如何使用它我们可以来简单实现下。

public class Lambda1 {
    
    public void test1(Consumer<String> consumer, String param) {
        consumer.accept(param);
        System.out.println(param);
    }

    public static void test2(String param) {
        param += "s";
        System.out.println(param);
    }

    
    public static void main(String[] args) {
        Lambda1 lambda1 = new Lambda1();
        lambda1.test1(s -> Lambda1.test2(s), "param");
        // 当然也可以指定参数类型，和上面同一个意思，一个参数时候没有什么意义，当多个参数时候
        // 可以根据指定参数类型，来调整参数顺序。否则就按照接口的参数顺序默认
        lambda1.test1((String s) -> Lambda1.test2(s), "param");
    }

}

如果对于lambda方法不好理解，可以写成匿名内部类，这样再去理解，就会好理解一点。比如：

public class Lambda1 {

    public void test1(Consumer<String> consumer, String param) {
        consumer.accept(param);
        System.out.println(param);
    }

    public static void test2(String param) {
        param += "s";
        System.out.println(param);
    }


    public static void main(String[] args) {
        Lambda1 lambda1 = new Lambda1();
        lambda1.test1(s -> Lambda1.test2(s), "param");
        lambda1.test1(new Consumer<String>() {
            @Override
            public void accept(String s) {
                Lambda1.test2(s);
            }
        }, "param");
    }

}

这两种写法其实是一致的，明显看到lambda的写法更加简洁。

consumer接口在Iterable接口中的forEach中有实现，我们在平时在使用list的forEach时候都会用到它，例如：

    public static void main(String[] args) {
        Lambda1 lambda1 = new Lambda1();
        lambda1.test1(s -> Lambda1.test2(s), "param");
        lambda1.test1(new Consumer<String>() {
            @Override
            public void accept(String s) {
                Lambda1.test2(s);
            }
        }, "param");
        
        List<Lambda1> lambda1s = new ArrayList<>();
        lambda1s.add(new Lambda1());
        lambda1s.add(new Lambda1());
        lambda1s.forEach(lambda11 -> Lambda1.test3(lambda1));
    }

 

Function

function的接口是有返回值。

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

例如：

public class Lambda1 {

    public void test1(Consumer<String> consumer, String param) {
        consumer.accept(param);
        System.out.println(param);
    }

    public static void test2(String param) {
        param += "s";
        System.out.println(param);
    }

    public static void test3(Lambda1 lambda1) {
        System.out.println(lambda1);
    }

    public void test4(Function<String, Lambda1> function, String param) {
        Lambda1 lambda1 = function.apply(param);
        System.out.println(lambda1);
    }

    public static Lambda1 getLambda1(String param) {
        return new Lambda1();
    }

    public static void main(String[] args) {
        Lambda1 lambda1 = new Lambda1();
        lambda1.test1(s -> Lambda1.test2(s), "param");
        lambda1.test1(new Consumer<String>() {
            @Override
            public void accept(String s) {
                Lambda1.test2(s);
            }
        }, "param");

        lambda1.test4(s -> Lambda1.getLambda1(s), "param");

    }

}

 

BiConsumer

public class Lambda2 {

    public void test1(BiConsumer<Lambda3, Lambda4> biConsumer) {
        Lambda3 lambda3 = new Lambda3();
        Lambda4 lambda4 = new Lambda4();
        biConsumer.accept(lambda3, lambda4);
    }
    
    public static void test2(Lambda3 lambda3, Lambda4 lambda4) {
        
    }

    class Lambda3 {
        public void test1(Lambda4 lambda4) {
            System.out.println(lambda4);
        }
    }

    class Lambda4 {

    }

    public static void main(String[] args) {
        Lambda2 lambda2 = new Lambda2();
        lambda2.test1((lambda3, lambda4) -> lambda3.test1(lambda4));
        lambda2.test1((lambda3, lambda4) -> Lambda2.test2(lambda3, lambda4));
    }
}

 

BiFunction

public class Lambda2 {
    
    private static final Lambda5 lambda5 = new Lambda5();

    public void test1(BiConsumer<Lambda3, Lambda4> biConsumer) {
        Lambda3 lambda3 = new Lambda3();
        Lambda4 lambda4 = new Lambda4();
        biConsumer.accept(lambda3, lambda4);
    }

    public static void test2(Lambda3 lambda3, Lambda4 lambda4) {

    }

    public void test3(BiFunction<Lambda3, Lambda4, Lambda5> biFunction) {
        Lambda3 lambda3 = new Lambda3();
        Lambda4 lambda4 = new Lambda4();
        Lambda5 lambda5 = biFunction.apply(lambda3, lambda4);
    }
    
    public static Lambda5 test4(Lambda3 lambda3, Lambda4 lambda4) {
        return lambda5;
    }
    

    class Lambda3 {
        public void test1(Lambda4 lambda4) {
            System.out.println(lambda4);
        }
    }

    class Lambda4 {

    }
    
    static class Lambda5 {

    }

    public static void main(String[] args) {
        Lambda2 lambda2 = new Lambda2();
        lambda2.test1((lambda3, lambda4) -> lambda3.test1(lambda4));
        lambda2.test1((lambda3, lambda4) -> Lambda2.test2(lambda3, lambda4));
        lambda2.test3((lambda3, lambda4) -> Lambda2.test4(lambda3, lambda4));
    }
}

方法引用

方法引用按照我的理解就是方法推断，根据lambda的调用，再改写成更简单的形式比如上面的例子：

public class Lambda2 {

    private static final Lambda5 lambda5 = new Lambda5();

    public void test1(BiConsumer<Lambda3, Lambda4> biConsumer) {
        Lambda3 lambda3 = new Lambda3();
        Lambda4 lambda4 = new Lambda4();
        biConsumer.accept(lambda3, lambda4);
    }

    public static void test2(Lambda3 lambda3, Lambda4 lambda4) {

    }

    public void test3(BiFunction<Lambda3, Lambda4, Lambda5> biFunction) {
        Lambda3 lambda3 = new Lambda3();
        Lambda4 lambda4 = new Lambda4();
        Lambda5 lambda5 = biFunction.apply(lambda3, lambda4);
    }

    public static Lambda5 test4(Lambda3 lambda3, Lambda4 lambda4) {
        return lambda5;
    }


    class Lambda3 {
        public void test1(Lambda4 lambda4) {
            System.out.println(lambda4);
        }
    }

    class Lambda4 {

    }

    static class Lambda5 {

    }

    public static void main(String[] args) {
        Lambda2 lambda2 = new Lambda2();
        // 由lambda2.test1((lambda3, lambda4) -> lambda3.test1(lambda4));改写
        lambda2.test1(Lambda3::test1);
        // 由lambda2.test1((lambda3, lambda4) -> Lambda2.test2(lambda3, lambda4));改写
        lambda2.test1(Lambda2::test2);
        lambda2.test3(Lambda2::test4);
    }
}

lambda表达式是一行的，都可以改写成方法引用的方式。所以对于那种对行方法的lambda，可以提出来一个方法，从而改成方法引用也可以，例如：

public class Lambda2 {

    public void test1(BiConsumer<Lambda3, Lambda4> biConsumer) {
        System.out.println("test1");
        Lambda3 lambda3 = new Lambda3();
        Lambda4 lambda4 = new Lambda4();
        biConsumer.accept(lambda3, lambda4);
        System.out.println("test1 end");
    }

    public void test5(Lambda3 lambda3, Lambda4 lambda4) {
        System.out.println("test5");
        System.out.println(lambda3);
        System.out.println(lambda4);
    }

    public void test6() {
        test1(this::test5);
    }

    class Lambda3 {
        public void test1(Lambda4 lambda4) {
            System.out.println(lambda4);
        }
    }

    class Lambda4 {

    }

    static class Lambda5 {

    }

    public static void main(String[] args) {
        Lambda2 lambda2 = new Lambda2();
        // lambda表达式
        lambda2.test1((lambda3, lambda4) -> {
            System.out.println(lambda3);
            System.out.println(lambda4);
        });
        // 改成方法引用
        lambda2.test1(lambda2::test5);
        // 也可以这样改成方法引用
        lambda2.test6();
    }
}

 

拓展

在map中也会由forEach方法，传入的是Biconsumer，我们也可以改写成方法引用的方式让其看起来更加优雅

public class Lambda6 {

    static class Lambda7 {}
    
    public static void main(String[] args) {
        Lambda6 lambda6 = new Lambda6();
        Lambda7 lambda7 = new Lambda7();
        Map<Lambda6, Lambda7> map = new HashMap<>();
        map.put(lambda6, lambda7);
        map.forEach((k, v) -> {
            System.out.println(k);
            System.out.println(v);
        });
       
    }

}

改写成方法引用的方式：

public class Lambda6 {

    static class Lambda7 {}

    public void test1(Lambda7 lambda7) {
        System.out.println(this);
        System.out.println(lambda7);
    }

    public static void main(String[] args) {
        Lambda6 lambda6 = new Lambda6();
        Lambda7 lambda7 = new Lambda7();
        Map<Lambda6, Lambda7> map = new HashMap<>();
        map.put(lambda6, lambda7);
        map.forEach(Lambda6::test1);
    }

}

 

总结

java8引入了函数式编程，有且只有一个抽象方法的接口是函数式接口，只有函数式接口才可以使用lambda表达式，只有方法参数的入参和出参都在函数式接口中，才能写成方法引用。

not back
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于java8的lambda的学习以及Consumer和BiConsumer实例
huqianlei的博客
02-12 3196
lambda基本格式为：参数 -> 表达式。 作用：将一块代码块传递到一个对象（定时器或者这个sort 方法），这个代码块将在未来某个时期被调用。 如： public class lambdaTest { public static void main(String[] args) { // 这是将代码块传递到sort String[] planets = ...
Java8函数式接口与lambda表达式的基本使用
weixin_45061591的博客
02-03 203
函数式接口即为只定义了一个接口方法(函数)的接口，例如：Runnable接口，JDK8提供多种函数式接口供我们使用，其中比较常见的有：等本文章主要介绍比较常见的函数式接口用法和lambda表达式
java8 BiFunction接口
墨笙弘一
01-31 1万+
这篇文章是对BiFunction函数式接口的学习总结。这里提醒一点，可以看出该接口中有方法的实现，不单单只有抽象方法，在java8中，有一个新的改进就是在现有的接口中增加了一些默认的方法实现，使用default关键字来修饰。这种做法不会影响以前代码对接口的实现，也对原有的接口进行了扩展。 传递行为给方法，而不是传递值。 /** * BiFunction是一个函数式接口，它接口两个参数并产生一个结...
【Java知识点】BiConsumer、Function的简单使用
等待中的小码农
11-28 874
BiConsumer、Function的简单使用
【Java】Jdk8函数接口Supplier、Function、Predicate、Consumer、BiFunction、BiPredicate、BiConsumer
zxcyxg123的博客
07-19 1616
Supplier、Function、Predicate、Consumer、BiFunction、BiPredicate、BiConsumer是Java函数式接口的一部分，它们用于定义不同类型的函数，从而在函数式编程中提供了更灵活的方式来处理数据。Supplier：表示一个供应商，它不接受任何参数，但返回一个结果。它的抽象方法为T get()，用于获取一个结果。Function：表示一个函数，它接受一个参数并返回一个结果。它的抽象方法为，用于将输入参数转换为输出结果。
Java8简单了解Lambda表达式与函数式接口
08-28
例如，Java中的Runnable接口是一个函数式接口，可以使用Lambda表达式来实现这个接口，例如：Runnable r = () -> System.out.println("Hello, World!");r.run();这里使用Lambda表达式将Runnable接口实现了，打印出...
Java8中Lambda表达式使用和Stream API详解
08-26
首先，Lambda表达式是Java8中的一个革命性变化，它允许开发者以一种更简洁、更易读的方式来表示匿名函数。在Java8之前，如果需要定义一个无名称的函数，通常需要创建一个内部类实现接口。Lambda表达式改变了这一情况...
Java8中的 Lambda表达式教程
08-31
Java 8 中的 Lambda 表达式是一种强大的编程特性，它允许我们以更简洁的方式编写函数式代码。Lambda 表达式本质上是一个匿名方法，它没有名称，但可以具有参数列表、箭头符号（->）和一个表达式或语句块。Lambda ...
Java 8 Function函数式接口及函数式接口实例
08-27
在Java 8中，`Function`接口是这些接口的一个典型代表。 `Function, R>`接口位于`java.util.function`包下，它定义了一个从类型`T`到类型`R`的转换方法`apply(T t)`。这个接口允许我们定义一个接受一个参数并返回一...
浅析Java8新特性Lambda表达式和函数式接口
08-29
* 基本语法： java8 中引入了新的操作符“->”，称为箭头操作符或者 lambda 操作符，箭头操作符将 lambda 拆分为两部分，左侧：lambda 表达式的参数列表，右侧：lambda 表达式中的所需要执行的功能（接口实现的功能...
函数式接口Consumer、BiConsumer、Supplier、Predicate、Function、BiFunction
最新发布
m0_46360888的博客
08-08 1283
函数式接口
死磕Lambda表达式（六）：Consumer、Predicate、Function复合
万猫学社
03-13 1万+
JDK不仅提供的这些函数式接口，其中一些接口还为我们提供了实用的默认方法，这次我们来介绍一下Consumer、Predicate、Function复合。
Java8中的函数式接口Supplier、Consumer、BiConsumer详解
Dream_it_possible！的博客
05-19 8145
函数式编程是JDK1.8的新特性，函数式接口是函数式编程主要的体现，我们可以借助函数接口在函数调用时使用lambda表达式。 一、什么是函数式接口? 函数式接口是java8中新加入的一批接口，他们由@FutionalInterface注解标记的接口，我们可以在rt.jar包下的java.util.function包里找到有很多函数式接口，比如常用的函数式接口有Function、Supplier、consumer和Prdicate等。 我们可以发现，函...
Java Lambda Consumer＜T＞ BiConsumer DoubleConsumer IntConsumer LongConsumer ObjDoubleConsumer ObjLong
热门推荐
02-10 2万+
Java Lambda Consumer<T> BiConsumer DoubleConsumer IntConsumer LongConsumer ObjDoubleConsumer ObjLongConsumer //Consumer<T> 提供一个T类型的输入参数，不返回执行结果 Consumer<String> c = (s) -> System.out.println(s); // Tom c.accept("Tom"); c.and
Lambda表达式笔记 一
fqzj__的博客
04-15 131
学习 Lambda表达式目的一些常用得函数接口和案例1 Function2 Supplier3 Consumer4 BiConsumer5 UnaryOperator6 BiFunction7 BinaryOperator 目的 我觉得其目的是为了让代码量更加简洁和根据实际环境去进行自动判断 应用场景在任何函数接口(只有一个抽象方法的接口是函数接口)都可以去使用其进行替换 一些常用得函数接口和案例 1 Function 这里注意有一个注解 @Functional Interface 其实这个注解就是注
java consumer 用法_如何在Java的lambda表达式中使用Consumer和BiConsumer接口？
weixin_34245171的博客
03-06 771
Consumer 接口是一个预定义的函数接口，可以在创建 lambda表达式或方法引用时使用。此接口表示接受单个输入参数且不返回任何内容的操作。它只包含一个名为 accept ()的方法。BiConsumer接口类似于 Consumer 接口，接受两个输入参数，不返回任何内容。语法@FunctionalInterfacepublicinterfaceConsumer@FunctionalInt...
lambda表达式BiComsumer
weixin_43842467的博客
09-26 259
今天遇到了一个非常老的接口,返回值是一个数组，下游把成员变量赋值成了String[]数组返回给我们，奇坑无比。 按照道理其实应该让他们改返回值的，但是下游坚决不改。无奈只有我们自己适配对象。 例： 下游返回 {“张三”，,“18”,“男”,“180cm”,“75KG”} 我们需要转换成对象User @Data public class User { private String name; private String age; private String sex; pri
总结之Function、Consumer等接口使用
IManiy的博客
07-31 1018
使用一： java可以通过Function、Consumer等接口的lambda表单式形式，提提取公共方法，把变化的部分的代码 放入lambda中，如下： xxxxxx aaaaaa xxxxxx xxxxxx bbbbbb xxxxxx 代码提取 public Result<User> loadRecords(Function<BpmInst,Boolean> function,List<Product>> query) { xxxx getxx（
Java 8 中需要知道的4个函数式接口-Function、Consumer、Supplier、Predicate
god23bin的博客之地
04-03 779
Java 8 中提供了许多函数式接口，包括Function、Consumer、Supplier、Predicate 等等。这 4 个接口就是本篇将要分享的内容
996视频学习笔记-20211115.docx
12-29
1 适合初级进阶 2 简单的总结记录 3 涵盖 java8新特性lambda，Stream API，Try-with-resource，Guava，线程池，Loombok，验证框架

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值