JDK8之函数式接口与方法引用

于 2023-04-09 16:01:04 发布
阅读量161 收藏
点赞数
分类专栏： # jdk8 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bluede2015/article/details/130043060
版权

一、函数式接口

1. 函数式接口的由来

​ 我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加方便，在JDK中提供了大量常用的函数式接口

public class Demo01Fun {

    public static void main(String[] args) {
        fun1((arr)->{
            int sum = 0 ;
            for (int i : arr) {
                sum += i;
            }
            return sum;
        });
    }

    public static void fun1(Operator operator){
        int[] arr = {1,2,3,4};
        int sum = operator.getSum(arr);
        System.out.println("sum = " + sum);
    }
}

/**
 * 函数式接口
 */
@FunctionalInterface
interface Operator{

    int getSum(int[] arr);
}

2. 函数式接口介绍

在JDK中帮我们提供的有函数式接口，主要是在 java.util.function 包中。

2.1 Supplier

​ 无参有返回值的接口，对于的Lambda表达式需要提供一个返回数据的类型。供应商的意思。

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

使用：

/**
 * Supplier 函数式接口的使用
 */
public class SupplierTest {

    public static void main(String[] args) {
        fun1(()->{
            int arr[] = {22,33,55,66,44,99,10};
            // 计算出数组中的最大值
            Arrays.sort(arr);
            return arr[arr.length-1];
        });
    }

    private static void fun1(Supplier<Integer> supplier){
        // get() 是一个无参的有返回值的 抽象方法
        Integer max = supplier.get();
        System.out.println("max = " + max);

    }
}

2.2 Consumer

​ 有参无返回值得接口,前面介绍的Supplier接口是用来生产数据的，而Consumer接口是用来消费数据的，使用的时候需要指定一个泛型来定义参数类型

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

使用：将输入的数据统一转换为小写输出

public class ConsumerTest {

    public static void main(String[] args) {
        test(msg -> {
            System.out.println(msg + "-> 转换为小写：" + msg.toLowerCase());
        });
    }

    public static void test(Consumer<String> consumer){
        consumer.accept("Hello World");
    }
}

默认方法:andThen

​ 如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法 andThen方法

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

具体的操作

public class ConsumerAndThenTest {

    public static void main(String[] args) {
        test2(msg1->{
            System.out.println(msg1 + "-> 转换为小写：" + msg1.toLowerCase());
        },msg2->{
            System.out.println(msg2 + "-> 转换为大写：" + msg2.toUpperCase());
        });
    }


    public static void test2(Consumer<String> c1,Consumer<String> c2){
        String str = "Hello World";
        //c1.accept(str); // 转小写
        //c2.accept(str); // 转大写
        //c1.andThen(c2).accept(str);
        c2.andThen(c1).accept(str);//先大写再小写  《==》 c2.accept(str)之后c1.accept(str)
    }
}

2.3 Function

​ 有参有返回值的接口，Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

使用：传递进入一个字符串返回一个数字

public class FunctionTest {

    public static void main(String[] args) {
        test(msg ->{
            return Integer.parseInt(msg);
        });
    }

    public static void test(Function<String,Integer> function){
        Integer apply = function.apply("666");
        System.out.println("apply = " + apply);
    }
}

默认方法：andThen，也是用来进行组合操作，

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

public class FunctionAndThenTest {

    public static void main(String[] args) {
        test(msg ->{
            return Integer.parseInt(msg);
        },msg2->{
            return msg2 * 10;
        });
    }

    public static void test(Function<String,Integer> f1,Function<Integer,Integer> f2){
        /*Integer i1 = f1.apply("666");
        Integer i2 = f2.apply(i1);*/
        Integer i2 = f1.andThen(f2).apply("666");// <===> f1.apply("666")之后f2.apply(i1)
        System.out.println("i2:" + i2);

    }
}

默认的compose方法的作用顺序和andThen方法刚好相反

而静态方法identity则是，输入什么参数就返回什么参数

2.4 Predicate

有参且返回值为Boolean的接口

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

使用：

public class PredicateTest {

    public static void main(String[] args) {
        test(msg -> {
            return msg.length() > 3;
        },"HelloWorld");
    }

    private static void test(Predicate<String> predicate,String msg){
        boolean b = predicate.test(msg);
        System.out.println("b:" + b);
    }
}

在Predicate中的默认方法提供了逻辑关系操作 and or negate isEquals方法

import java.util.function.Predicate;

public class PredicateDefaultTest {

    public static void main(String[] args) {
        test(msg1 -> {
            return msg1.contains("H");
        },msg2 -> {
            return msg2.contains("W");
        });
    }

    private static void test(Predicate<String> p1,Predicate<String> p2){
        /*boolean b1 = predicate.test(msg);
        boolean b2 = predicate.test("Hello");*/
        // b1 包含H b2 包含W
        
        // p1 包含H 同时 p2 包含W
        boolean bb1 = p1.and(p2).test("Hello");
        // p1 包含H 或者 p2 包含W
        boolean bb2 = p1.or(p2).test("Hello");
        // p1 不包含H
        boolean bb3 = p1.negate().test("Hello");
        System.out.println(bb1); // FALSE
        System.out.println(bb2); // TRUE
        System.out.println(bb3); // FALSE
    }
}

二、方法引用

1. 为什么要用方法引用

1.1 lambda表达式冗余

在使用Lambda表达式的时候，也会出现代码冗余的情况，比如：用Lambda表达式求一个数组的和

import java.util.function.Consumer;

public class FunctionRefTest01 {

    public static void main(String[] args) {
        printMax(a->{
            // Lambda表达式中的代码 和 getTotal中的代码冗余了
            int sum = 0;
            for (int i : a) {
                sum += i;
            }
            System.out.println("数组之和：" + sum);
        });
    }

    /**
     * 求数组中的所有元素的和
     * @param a
     */
    public void getTotal(int a[]){
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        System.out.println("数组之和：" + sum);
    }

    private static void printMax(Consumer<int[]> consumer){
        int[] a= {10,20,30,40,50,60};
        consumer.accept(a);
    }
}

1.2 解决方案

​ 因为在Lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一份逻辑了，这时我们就可以“引用”重复代码

import java.util.function.Consumer;

public class FunctionRefTest02 {

    public static void main(String[] args) {
        // :: 方法引用 也是JDK8中的新的语法
        printMax(FunctionRefTest02::getTotal);
    }

    /**
     * 求数组中的所有元素的和
     * @param a
     */
    public static void getTotal(int a[]){
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        System.out.println("数组之和：" + sum);
    }

    private static void printMax(Consumer<int[]> consumer){
        int[] a= {10,20,30,40,50,60};
        consumer.accept(a);
    }
}

:: 方法引用 也是JDK8中的新的语法。

方法引用会根据已经存在的方法直接引用，

而原本的lambda表达式会重新封装成一个方法。

这样看下来方法引用的效率会高点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OYtgY4yy-1681026101923)(JDK8新特性.assets/image-20220613151230912.png)]

2. 方法引用的格式

符号表示：::

符号说明：双冒号为方法引用运算符，而它所在的表达式被称为方法引用

应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。

常见的引用方式：

方法引用在JDK8中使用是相当灵活的，有以下几种形式：

  1. instanceName::methodName ===》对象::方法名

  2. ClassName::staticMethodName ===》类名::静态方法名

  3. ClassName::methodName ===》类名::普通方法（类名::实例方法名）

  4. ClassName::new ===》类名::new （类名::构造器）

  5. TypeName[]::new ===》String[]::new （数组::构造器）

2.1 对象名::方法名

这是最常见的一种用法。如果一个类中的已经存在了一个成员方法，则可以通过对象名引用成员方法

    public static void main(String[] args) {
        Date now = new Date();
        Supplier<Long> supplier = ()->{return now.getTime();};
        System.out.println(supplier.get());
        // 然后我们通过 方法引用 的方式来处理
        Supplier<Long> supplier1 = now::getTime;
        System.out.println(supplier1.get());
    }

方法引用的注意事项：

  1. 被引用的方法，参数要和接口中的抽象方法的参数一样
  2. 当接口抽象方法有返回值时，被引用的方法也必须有返回值

2.2 类名::静态方法名

也是比较常用的方式：

public class FunctionRefTest04 {

    public static void main(String[] args) {
        Supplier<Long> supplier1 = ()->{
            return System.currentTimeMillis();
        };
        System.out.println(supplier1.get());

        // 通过 方法引用 来实现
        Supplier<Long> supplier2 = System::currentTimeMillis;
        System.out.println(supplier2.get());
    }
}

2.3 类名::实例方法名

​ Java面向对象中，类名只能调用静态方法，类名引用实例方法是有前提的，实际上是拿第一个参数作为方法的调用者

import java.util.Date;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

public class FunctionRefTest05 {

    public static void main(String[] args) {
        Function<String,Integer> function = (s)->{
            return s.length();
        };
        System.out.println(function.apply("hello"));

        // 通过方法引用来实现
        Function<String,Integer> function1 = String::length;
        System.out.println(function1.apply("hahahaha"));

        BiFunction<String,Integer,String> function2 = String::substring;
        String msg = function2.apply("HelloWorld", 3);
        System.out.println(msg);
    }
}

2.4 类名::构造器

​ 由于构造器的名称和类名完全一致，所以构造器引用使用::new的格式使用，

public class FunctionRefTest06 {

    public static void main(String[] args) {
        Supplier<Person> sup = ()->{return new Person();};
        System.out.println(sup.get());
        // 然后通过 方法引用来实现
        Supplier<Person> sup1 = Person::new;
        System.out.println(sup1.get());
        BiFunction<String,Integer,Person> function = Person::new;
        System.out.println(function.apply("张三",22));
    }
}

2.5 数组::构造器

​ 数组是怎么构造出来的呢？

    public static void main(String[] args) {
        Function<Integer,String[]> fun1 = (len)->{
            return new String[len];
        };
        String[] a1 = fun1.apply(3);
        System.out.println("数组的长度是：" + a1.length);
        // 方法引用 的方式来调用数组的构造器
        Function<Integer,String[]> fun2 = String[]::new;
        String[] a2 = fun2.apply(5);
        System.out.println("数组的长度是：" + a2.length);
    }

小结：方法引用是对Lambda表达式符合特定情况下的一种缩写方式，它使得我们的Lambda表达式更加的精简，也可以理解为lambda表达式的缩写形式，不过要注意的是方法引用只能引用已经存在的方法。

大仙andrew
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-JDK8新特性总结-接口方法/Lambda/方法引用/Optional
07-12
内容：包括接口中的方法/Lambda/方法引用/Optional/函数式接口 适合人群：有一定编程基础及Java基础的伙伴 使用场景：开发和面试题中都会用到，开发中合理运用Java 8新特性可以大大简化代码量，提高开发效率，在Java...
JDK8新特性（pdf版）
06-26
JDK8新特性课程内容包括了解Java发展史、Lambda表达式、接口的增强、函数式接口、方法引用、Stream API、Optional、新时间日期API等。 一、Java发展历史 Java的发展历史可以追溯到1991年，Sun公司成立了一个称为...
JDK8——函数式编程
ThinkMore
01-07 267
核心函数接口 接口 参数 返回类型 描述 Predicate T boolean 用于判别一个对象。比如求一个人是否为男性 Consumer T void 用于接收一个对象进行处理但没有返回，比如接收一个人并打印他的名字 Function T R 转换一个对象为不同类型的对象 Supplier None T 提供一个对象 UnaryOperator T T 接收对象...
JDK8 函数式编程
失措*的博客
06-29 162
JDK8 函数式编程 1.接口中与默认方法（Default Methods） 接口中通过defalut关键字向接口中添加非抽象方法，此功能也叫**虚拟扩展方法** 默认方法直接可以实现。例子： public interface Person { void eat(); default void paly(){ System.out.println("通用的chi"); } } public class Tom implements Pe
JDK 8 函数式编程入门
泽佑兄弟 ZYbros
10-25 516
来源 http://www.cnblogs.com/snowInPluto/p/5981400.html 1. 概述 1.1 函数式编程简介 我们最常用的面向对象编程（Java）属于命令式编程（Imperative Programming）这种编程范式。常见的编程范式还有逻辑式编程（Logic Programming），函数式编程（Functional Programming）。
4、jdk8-函数式接口简单使用
spring_boot的博客
04-11 186
本内容取自官方示例,并加以小测试使用 1、函数接口说明 函数式接口的定义: 有一个抽象方法的普通接口就是函数式接口（静态与默认方法不算），默认继承object，覆盖父类方法也不算; 任何函数式接口都可以使用lambda表达式替换 这个注解可存在可不存在，有定义多于一个方法时存在则出错 @FunctionalInterface interface Fun { void foo(); ...
Java jdk8 函数式编程
天空之城的博客
10-10 164
函数式接口 函数式接口中只能有一个抽象方法 Java8之前已经存在的函数式接口有： java.lang.Runnable java.util.concurrent.Callable java.security.PrivilegedAction java.util.Comparator java.io.FileFilter java.nio.file.PathMatcher java.lang...
mac os jdk8
09-23
Stream API −新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。 Date Time API − 加强对日期与时间的处理。 Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空...
JDK1.8 - windows版本，又称之为Java 8
04-18
JDK1.8，又称之为Java 8，是Java语言开发的一个主要版本。Oracle公司于2014年3月18日发布，它支持函数式编程，新的JavaScript引擎，新的日期API，新的Stream API...*函数式接口 *方法引用与构造器引用 *新的Stream API
JDK都出到14了,你有什么理由不会函数式编程(推荐)
08-19
在Java中，函数式接口指的是只有一个抽象方法的接口，这个特性使得它们成为Lambda表达式和方法引用的目标类型。在Java 8中，官方定义了一个`@FunctionalInterface`注解，用于明确声明一个接口是函数式的。这样的接口...
JDK8新特性-函数式编程
时光
04-07 1248
JDK8新特性-函数式编程
jdk8新特性之函数式编程
budongfengqing的博客
08-23 428
jdk8新特性之函数式编程参考文档/内容：一、原书问题和内容的阐述1.1、Java怎么又变了二、函数编程2.1、什么是函数编程？2.2、函数式接口2.3、Lambda表达式(匿名函数)的介绍2.4、方法引用 参考文档/内容：     本系列文章内容主要来自于《java8 实战》，加上了自己一些想法和重写编写的例子，主要目的是为了加深自己的印象，方便后期的复习。     所以有任何问题请购阅《java8 实战》内容，支持正版。 一、原书问题和内容的阐述 1.1、Java怎么又变了   原因具体如下： 因为之
JDK8新特性03-函数式接口
程序员飞扬的博客
06-04 971
java8函数式接口
JDK8—函数式处理(I)
理想主义
05-25 357
引入流流是啥流与集合流的操作 流是啥 流是JavaAPI的新成员，它允许你以声明性方式处理数据集合。 例如：实现返回热量低的菜肴的名称 jdk7 List<Dish> lowCaloricDishes = new ArrayList<>(); for(Dish d : menu){ if(d.getCalories()<400){ lowCaloricDis...
一文教会你JDK8的函数式编程
打酱油的葫芦娃
02-23 6735
JDK8的1个新特性就是支持函数式接口(Functional Interface)。 函数式接口就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。 函数式接口可以被隐式转换为Lambda表达式。 我们也可以自行定义函数式接口，如: @FunctionalInterface interface GreetingService{ void sayMessage(String message); } 然后通过Lambda表达式来定义接口实现(JAVA8之前一般使用匿名类来实现): public c
函数式接口实例化的替代方案
热门推荐
墨言的博客
06-01 1万+
Lambda表达式入门必看博客
Lambda表达式
qq_44694100的博客
11-27 90
Lambda表达式的标准格式： 由三部分组成： a.一些参数 b.一个箭头 c.一段代码 格式： (参数列表)->{一些重写方法的代码}; 解释说明格式： ():接口中抽象方法的参数列表，没有参数就空着，有参数就写参数，多个参数使用逗号分隔 ->:传递的意思，把参数传递给方法体{} {}:重写接口的抽象方法体 例1： //使用匿名内部类实现多线程 new Thread(new Runnable() { @Override publ
java 重构函数_包会，教你用Java函数式编程重构烂代码
weixin_39729272的博客
02-13 330
Java8 由Oracle在2014年发布，是继Java5之后最具革命性的版本。Java8吸收其他语言的精髓带来了函数式编程，lambda表达式，Stream流等一系列新特性，学会了这些新特性，可以让你实现高效编码优雅编码。烂代码登场首先引入一个实际的例子，我们常常会写一个dao类来操作数据库，比如查询记录，插入记录等。下面的代码中实现了查询和插入功能(引入Mybatis三方件)：publicc...
jdk1.8 函数式接口
最新发布
08-17
- *1* [jdk1.8之函数式接口](https://blog.csdn.net/liu_shi_jun/article/details/128562977)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值