4.函数式接口

最新推荐文章于 2023-09-14 23:01:58 发布
最新推荐文章于 2023-09-14 23:01:58 发布
阅读量326 收藏
点赞数
分类专栏： Java基础和进阶 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45940433/article/details/122043212
版权

1. 函数式接口概述

函数式接口：有且仅有一个抽象方法的接口

Java中的函数式编程体现的就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口。

只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利的进行推导。

如何检测一个接口是不是函数式接口：

  • @FunctionalInterface
  • 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败

注意：自己定义函数式接口时@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口；不过建议加上注解。

代码示例

  • 接口
package Study01;

@FunctionalInterface//函数式接口注解
public interface MyInterface {
    void show();
}
  • 测试类
package Study01;
/*函数式接口：有且仅有一个抽象方法的接口*/
public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterface my = ()-> System.out.println("我最帅");
        my.show();
    }
}

2.函数式接口作为方法的参数

需求：

  • 定义一个类(RunnableDemo),在类中提供两个方法
    • 一个方法是startThread(Runnable r)方法参数Runnable是一个函数式接口
    • 一个方法是主方法，在主方法中调用startThread方法

如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为阐述传递。

  •   startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));

代码示例：

  •   package Study02;
  
  /*
  需求：
  - 定义一个类(RunnableDemo),在类中提供两个方法
  	- 一个方法是startThread(Runnable r)方法参数Runnable是一个函数式接口
  	- 一个方法是主方法，在主方法中调用startThread方法
  	*/
  public class RunnableDemo {
      public static void main(String[] args) {
          //在主方法中调用startThread方法
  
          //匿名内部类的方法实现
          startThread(new Runnable() {
              @Override
              public void run() {
                  System.out.println(Thread.currentThread().getName() + "线程启动了");
              }
          });
  
          //Lambda表达式
          startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));
      }
  
      public static void startThread(Runnable r) {
          Thread t = new Thread(r);
          t.start();
      }
  }

3.函数式接口作为方法的返回值

需求：

  • 定义一个类(ComparatorDemo),在类中提供两个方法
    • 一个方法是：Comparator<String>getComparator() 方法返回值Comparator是一个函数式接口
    • 一个方法是主方法，在主方法中调用getComparator方法

注：如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回。

代码示例：

  • ComparatorDemo类
package Study02;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/*
需求：
- 定义一个类(ComparatorDemo),在类中提供两个方法
	- 一个方法是：Comparator<String>getComparator()  方法返回值Comparator是一个函数式接口
	- 一个方法是主方法，在主方法中调用getComparator方法
*/
public class ComparatorDemo {
    public static void main(String[] args) {
        //构造场景
        //定义集合
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("cccc");
        arrayList.add("aa");
        arrayList.add("b");
        arrayList.add("ddd");
        System.out.println("排序前" + arrayList);//排序前[cccc, aa, b, ddd]
        Collections.sort(arrayList);
        System.out.println("排序后" + arrayList);//排序后[aa, b, cccc, ddd]
        Collections.sort(arrayList, getComparator());
        System.out.println("最后排序" + arrayList);//最后排序[b, aa, ddd, cccc]

    }

    private static Comparator<String> getComparator() {
        //使用匿名内部类的方法实现
//        Comparator<String> comparator = new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };
//        return comparator;

        //缩减版
//        return new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };

        //使用Lambda表达式
        return (s1, s2) -> s1.length() - s2.length();

    }
}

4.常用的函数式接口

Java 8在java.util.function包下预定义了大量的函数式接口

常用的有下面四个：

  • Supplier接口
  • Consumer接口
  • Predicate接口
  • Function接口

1、Supplier接口

Supplier:包含一个无参的方法

  • T get():获得结果
  • 该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据。
  • Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。

代码示例：

package Study02;

import java.util.function.Supplier;

/*
Supplier<T>:包含一个无参的方法
- T get():获得结果
- 该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据。
- Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。
*/
public class SupplierDemo {
    public static void main(String[] args) {
//        String s = getString(()->{
//            return "我最帅";
//        });
        String s = getString(()->"我最帅");
        System.out.println(s);

        Integer i = getInteger(()->100);
        System.out.println(i);
    }
    //定义一个方法，返回值是整数类型
    private static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }
    //定义一个方法，返回值为字符串类型
    private static String getString(Supplier<String> sup){
        return sup.get();
    }
}

练习：

  • 定义一个类(SupplierTest),在类中提供两个方法
    • 一个方法是：int getMax(Supplier <Integer> sup) 用于返回一个int数组中的最大值。
    • 一个方法是主方法，在主方法中调用getMax方法

代码：

package Study02;

import java.util.function.Supplier;

/*练习：
- 定义一个类(`SupplierTest`),在类中提供两个方法
	- 一个方法是：`int getMax(Supplier <Interger> sup)` 用于返回一个`int`数组中的最大值。
	- 一个方法是主方法，在主方法中调用`getMax`方法
	*/
public class SupplierTest {
    public static void main(String[] args) {
        //定义一个int类型的数组
        int []arr = {19,22,33,44,11,1090};
        //调用函数
        int Max = getMax(()->{
            //判断最大值并返回
           int max = arr[0];
           for (int i = 1;i<arr.length;i++){
               if (arr[i]>max){
                   max = arr[i];
               }
           }
           //输出最大值
            return max;
        });
        System.out.println("数组中的最大值为："+Max);
    }

    //返回一个`int`数组中的最大值。
    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

2.Consumer接口

Consumer:包含两个方法

  • void accept(T t):对给定的参数执行此操作
  • default ConsumerandThen(Consumer after):返回一个组合的Consumer，依次执行此操作，然后执行after操作。
  • Consumer接口也被称为消费型接口，它消费的数据的数据类型由泛型指定。

代码：

package Study02;

import java.util.function.Consumer;

/*
  Consumer<T>:包含两个方法
- void accept(T t):对给定的参数执行此操作
- default Consumer<T>andThen(Consumer after):返回一个组合的Consumer，依次执行此操作，然后执行after操作。
- Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定。
*/
public class ConsumerDemo {
    public static void main(String[] args) {
//        operaterString("帅哥",(String s)->{
//            System.out.println(s);
//        } );
        operaterString("帅哥",s-> System.out.println(s));
//        operaterString("帅哥",System.out::println);

        //实现字符串反转
//        operaterString("帅哥",s->{
//            System.out.println(new StringBuilder(s).reverse().toString());
//        });
        //改进
        operaterString("帅哥",s-> System.out.println(new StringBuilder(s).reverse().toString()));
        System.out.println("========================");

        operaterString("帅哥",s-> System.out.println(s),s -> System.out.println(new StringBuilder(s).reverse().toString()));
    }
    //定义一个方法，用不同的方式消费同一个字符串两次
    private static void operaterString(String name, Consumer<String> con1,Consumer<String> con2){
//        con1.accept(name);
//        con2.accept(name);
        con1.andThen(con2).accept(name);
    }
    //定义一个方法，消费一个字符串数据
    private static void operaterString(String name, Consumer<String> con){
        con.accept(name);
    }
}

练习：

  • String[] strArray ={“迪丽热巴,18”,“王冰冰,18”,”古力娜扎，18”}；
  • 字符串中有多条信息，请按照格式：“姓名：xx，年龄：xx”的格式将信息打印出来
  • 要求
    • 把打印姓名的动作作为第一个Consumer接口的Lambda实例。
    • 把打印年龄的动作作为第二个Consumer接口的Lambda实例。
    • 将两个Consumer接口按照顺序组合到一起使用。

代码：

package Study02;

import java.util.function.Consumer;

/*
- String[] strArray ={"迪丽热巴,18","王冰冰,18","古力娜扎,18"};
- 字符串中有多条信息，请按照格式：“姓名：xx，年龄：xx”的格式将信息打印出来
- 要求
	- 把打印姓名的动作作为第一个Consumer接口的Lambda实例。
	- 把打印年龄的动作作为第二个Consumer接口的Lambda实例。
	- 将两个Consumer接口按照顺序组合到一起使用。
*/
public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"迪丽热巴,18", "王冰冰,18", "古力娜扎,18"};

        operationString(strArray, (String str) -> {
            String name = str.split(",")[0];
            System.out.print("姓名：" + name);
        }, (String str) -> {
            int age = Integer.parseInt(str.split(",")[1]);
            System.out.println(",年龄：" + age);
        });
    }

    private static void operationString(String[] people, Consumer<String> con1, Consumer<String> con2) {
        for (String peo : people) {
            con1.andThen(con2).accept(peo);
        }
    }
}

3.Predicate接口

Predicate<T>:常用的四个方法

方法说明
boolean test(T t)对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
default Predicate<T> negate()返回一个逻辑否定，对应逻辑非
default Predicate<T>and(Predicate other)返回一个组合判断，对应短路与
default Predicate<T>or(Predicate other)返回一个组合判断，对应短路或

代码：

  • boolean test(T t)和default Predicate<T> negate()示例：
package Study03;

import java.util.function.Predicate;

/*
| boolean test(T t)             | 对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值 |
| default Predicate<T> negate() | 返回一个逻辑否定，对应逻辑非                                 |
*/
public class PredicateDemo {
    public static void main(String[] args) {
//        boolean b1 = checkString("hello world", (String s) -> {
//            return s.length() > 8;
//        });
        boolean b1 = checkString("hello",(s)->s.length()>8);
        System.out.println(b1);
        boolean b2 = checkString("hello world",(s)->s.length()>8);
        System.out.println(b2);

    }

    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
//        return pre.test(s);
//        return !pre.test(s);
        return pre.negate().test(s);
    }
}
  • default Predicate<T>and(Predicate other)和default Predicate<T>or(Predicate other)代码示例：
package Study03;

import java.util.function.Predicate;

/*
| default Predicate<T>and(Predicate other) | 返回一个组合判断，对应短路与 |
| default Predicate<T>or(Predicate other)  | 返回一个组合判断，对应短路或 |
*/
public class PredicateDemo2 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", (s) -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString("helloworld", (s) -> s.length() > 8);
        System.out.println(b2);

        boolean b3 = checkString("hello",s->s.length()>8,s->s.length()<15);
        System.out.println(b3);
        boolean b4 = checkString("helloworld",s->s.length()>8,s->s.length()<15);
        System.out.println(b4);

        boolean b5 = checkString("helloworld",s->s.length()>15,s->s.length()>13);
        System.out.println(b5);
    }
    //同一个字符串给出两个不同的判断条件，最后把两个判断的结果做逻辑与/或运算的结果作为结果
    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
        //逻辑与运算
//        boolean b1 = pre1.test(s);
//        boolean b2 = pre2.test(s);
//        boolean b = b1 && b2;
//        return b;
//        return pre1.and(pre2).test(s);

        //逻辑或运算
        return pre1.or(pre2).test(s);
    }

    //判断字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);
    }
}

练习：

  • String[] strArray = {“王冰冰,18”,”迪丽热巴,19”,”天才小火龙,18”,”伤心排骨玉米汤,17”};
  • 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
  • 同时按如下要求：姓名长度大于2，年龄小于20

代码：

package Study03;

import java.util.ArrayList;
import java.util.function.Predicate;

/*
- `String[] strArray = {“王冰冰,18”,”迪丽热巴,19”,”天才小火龙,18”,”伤心排骨玉米汤,17”};`
- 字符串数组中有多条信息，请通过`Predicate`接口的拼装将符合要求的字符串筛选到集合`ArrayList`中，并遍历`ArrayList`集合
- 同时按如下要求：姓名长度大于2，年龄小于20
*/
public class PredicateTest {
    public static void main(String[] args) {
        //定义并初始化集合
        String[] strArray = {"王冰冰,18","迪丽热巴,19","天才小火龙,18","伤心排骨玉米汤,17","明磊,24"};
        //调用checkString方法
       ArrayList<String> arrayList =  checkString(strArray,
               s-> s.split(",")[0].length() > 2,
               s -> Integer.parseInt(s.split(",")[1])<20);
       //遍历输出
        for (String str:arrayList){
            System.out.println(str);
        }
    }

    //通过`Predicate`接口的拼装将符合要求的字符串筛选到集合`ArrayList`中，并遍历`ArrayList`集合
    private static ArrayList<String> checkString(String[] strArray, Predicate<String> pre1, Predicate<String> pre2){
        //定义一个集合
        ArrayList<String> arrayList = new ArrayList<String>();
        //遍历数组
        for (String str:strArray){
            if (pre1.and(pre2).test(str)){
                arrayList.add(str);
            }
        }
        //返回集合
        return arrayList;
    }
}

4.Function接口

Function<T,R>:常用的两个方法

  • R apply(T t):将此函数应用于给定的参数
  • defult<V> Function andThen(Function after):返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
  • Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值。

示例代码：

package Study04;

import java.util.function.Function;

/*
`Function<T,R>`:常用的两个方法
- `R apply(T t)`:将此函数应用于给定的参数
- `defult<V> Function andThen(Function after)`:返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
- `Function<T,R>`接口通常用于对参数进行处理，转换(处理逻辑由`Lambda`表达式实现)，然后返回一个新的值。
*/
public class FunctionDemo {
    public static void main(String[] args) {
        //调用convert方法
        convert("100", s -> Integer.parseInt(s));
        //调用add方法
        add(100, s -> String.valueOf(s + 100));
        //调用ConvertAndAdd方法
        ConvertAndAdd("100",s->Integer.parseInt(s),s->String.valueOf(s+200));
    }

    //定义一个方法，把一个字符串转换int类型，在控制台输出
    private static void convert(String s, Function<String, Integer> fun) {
        Integer i = fun.apply(s);
        System.out.println(i);
    }

    //定义一个方法，把一个int类型的数据加上一个整数后，转为字符串在控制台输出
    private static void add(int a, Function<Integer, String> add) {
        String i = add.apply(a);
        System.out.println(i);
    }

    //定义一个方法，把一个字符串转换为int类型，把int类型的数据加上一个整数后，转换为字符换在控制台输出。
    private static void ConvertAndAdd(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
        String apply = fun1.andThen(fun2).apply(s);
        System.out.println(apply);
    }
}

练习：按照指定要求操作数据

  • String s = “王冰冰,19”;
  • 请按照指定的要求进行操作
    • 将字符串截取得到数字年龄部分
    • 将上一步的年龄字符串转换为int类型的数据
    • 将上一步的int数据加1，得到一个int结果，在控制台输出
  • 通过Function接口来实现函数拼接
package Study04;

import java.util.function.Function;

/*练习：按照指定要求操作数据
- String s = “王冰冰,19”;
- 请按照指定的要求进行操作
	- 将字符串截取得到数字年龄部分
	- 将上一步的年龄字符串转换为int类型的数据
	- 将上一步的int数据加1，得到一个int结果，在控制台输出
- 通过Function接口来实现函数拼接
*/
public class FunctionTest {
    public static void main(String[] args) {
        String s = "王冰冰,18";
        //Convert(s,s1->s1.split(",")[1],s2->Integer.parseInt(s2),s3->s3+1);
        Convert(s,s1->s1.split(",")[1],Integer::parseInt,s3->s3+1);
    }

    private static void Convert(String s, Function<String, String> fun1, Function<String, Integer> fun2,Function<Integer,Integer>fun3) {
        Integer apply = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(apply);
    }
}
幺洞两肆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java的函数式接口讲解代码（ 函数式接口定义、 函数式接口实战、内置函数式接口...）
06-27
4. 函数式库开发：本源码资源对函数式接口的设计和实现提供了参考，使得用户能够开发出自己的函数式库，为其他开发者提供便利的函数式编程工具。 本源码资源旨在帮助用户掌握以下几个方面： 1. 函数式编程基础概念...
使用泛型定义interface函数接口
YZ_ZZZ24的博客
10-09 631
【代码】使用泛型定义interface函数接口。
java8-接口的默认方法/静态方法/函数式接口 定义与使用
MayMatrix 的博客
09-06 1041
其实之前在讲Lambda表达式的时候提到过，所谓的函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法。这种类型的接口也称为SAM接口，即Single Abstract Method interfaces。
Java 8 Functional Interfaces – 什么时候/在哪里使用?
alexdyysp的博客
09-12 194
Java 8 Functional Interfaces – 什么时候/在哪里使用?一、定义 函数式接口，lambda 表达式和 Stream API – Java 8的这三个功能将Java编程变成了一种称为函数式编程的新型编程样式。 Java仍然是一种面向对象的编程语言，但是从Java 8开始，随着新功能的引入，大多数编程都是在考虑功能而不是对象的情况下完成的。 在本文中，我们将看到 Java 8 函数式接口 @FunctionalInterface 注解，java.util.function包，以及如
Java的interface应用和面向接口编程
最新发布
zhangbeizhen18的博客
09-14 955
记录：477 场景：Java的关键字interface应用，一个接口，多个实现类。面向接口编程，把业务逻辑线提取出来作为接口，具体的业务实现通过该接口的实现类来完成。
C++语言中的模板——函数模板
qq_45652092的博客
11-14 461
模板概述： c++提供了函数模板(function template.)所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数 就成为函数模板。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函 数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板 中的虚拟类型，从而实现不同函数的功能。 c++提供两种模板机制:函数模板和类模板 类属 - 类型参数化，又称参数模板 函数模板 函数模板的引入： 如果我们需要实现两个变量相交换： 整
JDK1.8【函数式接口】【定义与使用】【源码】
04-19
JDK1.8【函数式接口】【定义与使用】【源码】 文章地址：https://blog.csdn.net/m0_37969197/article/details/124146253 * 函数式接口（类的定义与适应形式，只是一种类的定义形式，属于新增语法） * 包：java....
Java 8新特性 内建函数式接口详解
09-01
主要介绍了Java 8新特性 内建函数式接口详解的相关资料,这里主要介绍4个基本函数式接口，需要的朋友可以参考下
0202年了，还没有用上Java函数式编程！！！——Lambda表达式
12-21
——Lambda表达式函数式编程是什么命令式编程(Imperative)声明式编程(Declarative)函数式编程(Functional)总结函数式编程的好处Lambda表达式函数式接口五种形式1.无参数2.有单个参数3.有多个参数4.实现有多行5.带...
ASP.NET.4揭秘
06-08
17.1.10 声明接口569 17.1.11 使用访问修饰符570 17.1.12 智能提示和组件571 17.1.13 在组件中使用asp.net内部对象573 17.2 创建组件库575 17.2.1 编译组件库575 17.2.2 向类库中添加引用578 17.3 架构思考581 ...
C的常用模板函数接口 --字符串操作、排序等
xiyuan255的博客
03-06 552
/**! * 2018年1月29日10:28:50 * Author: xiyuan255 * 快速排序的模板代码 */ #define __STATIC_INLINE static inline typedef Cali_Fix_t DataType; __STATIC_INLINE uint32_t getCompValue( const void *pCurren...
函数式接口
可乐葱花
03-23 301
主要内容: 1: 自定义函数式接口 2: 函数式编程 3: 常用函数式接口 3.1 Supplier 你要作为一个供应者,自己生产数据 3,2 Consumer 你要作为一个消费者,利用已经准备数据 3.1 Supplier 你要作为一个供应者,自己生产数据 3,2 Consumer 你要作为一个消费者,利用已经准备数据 3.3...
Java基础-常用的函数式接口的学习
二丫的博客
11-04 505
常用的函数式接口 Java8 在java.uti.funcation包下预定义了大量的函数式接口提供我们使用 我们重点学习： Supplier接口 Consumer接口 Predicate接口 Function接口 Supplier接口 Supplier<T>:包含一个无参的方法 T get():获得参数 该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现）返回一个数据 Supplier<T&g
函数式接口概述和定义（三）
qq_41857955的博客
01-20 1883
函数式接口，就是java类型系统中的接口，包含一个方法的特殊接口 语义化检测注解：@Functionallnterface 用户身份认证的接口 @FunctionalInterface public interface UserIdentify { /* * 通过用户的账号，验证用户身份信息的接口 * @param username 验证的用户账号 * @retu...
C++逻辑设计——函数设计之函数接口说明
Hansry的博客
05-09 7726
1.函数接口说明 在C++中指定函数接口时，一些必须要解决的问题有： (1) 运算符函数还是非运算符函数？ (2) 自由运算符还是成员运算符？ (3) 虚函数还是非虚函数？ (4) 纯虚成员函数还是非纯虚成员函数？ (5) 静态成员函数还是非静态成员函数？ (6) 常量成员函数还是非常量成员函数？ (7) public、protected 还是 private 成员函数？ (8)...
C的常用模板函数接口2 --字符串操作、排序等
xiyuan255的博客
08-29 304
/* 以下代码是测试动态库libxiyuan.so或静态库xiyuanlib.a的容器 操作的testVessel.c源代码。 其中：(该版本加入容器属性) 1.加入容器属性，VAssemble_t类型的容器，可以接收任何类型的 数据，内核使用的是线性循环双向链表。 2.该容器可以对数据根据比较函数的不同，进行不同的排序； 3.该容器可以根据key值的和...
函数模板
cindywry的博客
11-12 124
函数模板提供一个种用来自动生成各种类型函数实例的算法，程序员对于函数接口，参数和返回类型中的全部或者部分类型进行参数化 parameterize 而函数体保持不变。 如用一个函数的实现在一组实例上保持不变，并且每个实例都处理一种惟一的数据类型，如函数 min() 则该函数就是模板的最佳候选者。 关键字 template 总是放在模板的定义与声明的最前面，关键字后面是用逗号分隔的模板参数表 tem...
Java函数式接口的执行流程
weixin_39162597的博客
04-16 471
Java函数式接口@FunctionalInterface前言一、先搞明白什么是函数式接口？二、Runnable调用流程解析1.示例代码2.核心真谛 前言 JDK1.8新特性推出了函数式接口，下面以Runnable举例来说明它的执行流程，希望能帮助大家正确理解函数式接口。 一、先搞明白什么是函数式接口？ 函数式接口是指只有一个抽象方法的接口(当前这里不包括默认方法和接口静态方法)。可以使用@FunctionalInterface 这个注解，正式的声明，但也可以省略。针对有多个抽象方法的接口，使用@F..
java8函数式接口妙用
07-28
4. 并行计算：函数式接口可以方便地支持并行计算。通过使用函数式接口，可以将任务分解成多个子任务，并发执行，提高程序的性能。 5. Optional类：函数式接口在Java 8中引入的Optional类中也有广泛应用。Optional类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

幺洞两肆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值