【jdk1.8特性】之Function

最新推荐文章于 2024-05-11 12:15:21 发布
最新推荐文章于 2024-05-11 12:15:21 发布
阅读量8.1k 收藏 36
点赞数 8
分类专栏： jdk1.8特性 文章标签： Function函数 Function Function使用示例 Function介绍 JDK8特性
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justry_deng/article/details/100886475
版权

笔者日常： 来吧，Function~

相关声明：

  • 本文按照以下顺序进行说明并给出简单的使用示例：

    序号接口
    1Function<T, R>
    2IntFunction<R>
    3DoubleFunction<R>
    4LongFunction<R>
    5ToIntFunction<T>
    6ToLongFunction<T>
    7ToDoubleFunction<T>
    8IntToDoubleFunction
    9IntToLongFunction
    10LongToDoubleFunction
    11LongToIntFunction
    12DoubleToIntFunction
    13DoubleToLongFunction
    14BiFunction<T, U, R>
    15ToIntBiFunction<T, U>
    16ToLongBiFunction<T, U>
    17ToDoubleBiFunction<T, U>

  • 先给出下文的示例中所涉及到的模型：

    /**
 * 员工实体模型
 *
 * @author JustryDeng
 * @date 2019/7/15 19:48
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Staff implements Serializable {

    /** 姓名 */
    private String name;

    /** 年龄 */
    private Integer age;

    /** 工号 */
    private String staffNo;

}

Function<T, R>：

  • R apply(T t)： 输入T类型的参数，运行相关逻辑后，返回R类型的结果。
    使用示例：

    /**
 *  R apply(T t): 输入T类型的参数，运行相关逻辑后，返回R类型的结果。
 */
@Test
public void test1() {
    Function<String, Staff> function = x -> {
        Staff s = new Staff();
        s.setName(x + ", 咿呀咿呀哟!");
        return s;
    };

    Staff staff = function.apply("邓某");
    // 输出: 邓某, 咿呀咿呀哟!
    System.out.println(staff.getName());
}

  • Function<V, R> compose(Function<? super V, ? extends T> before)： 由两个旧的Function得到一个新的Function。

    假设： 现有式子functionC = functionB.compose(functionA)，functionA 泛型为<P1, R1>， functionB泛型为<R1, R2>。

    那么， 上述式子的逻辑是：先运行functionA<P1, R1>的apply方法，然后将其返回值作为functionB<R1, R2>的apply方法的入参，执行functionB<R1, R2>的apply方法，返回一个泛型为<P1, R2>的functionC<P1, R2>。

    使用示例：

     /**
  * <V> Function<V, R> compose(Function<? super V, ? extends T> before):由两个旧的Function得到一个新的Function。
  *
  * 假设：现有式子functionC = functionB.compose(functionA)，
  *      functionA泛型为<P1, R1>， functionB泛型为<R1, R2>。
  *
  * 那么，上述式子的逻辑是:先运行functionA<P1, R1>的apply方法，然后将其返回值
  *                     作为functionB<R1, R2>的apply方法的入参，执行
  *                     functionB<R1, R2>的apply方法，返回一个泛型为
  *                     <P1, R2>的functionC<P1, R2>。
  */
 @Test
 public void test2() {
 
     Function<String, Integer> functionA = x -> {
         Objects.requireNonNull(x, "参数不能为空");
         x = x.replace(" ", "");
         return x.length();
     };
 
     Function<Integer, Staff> functionB = x -> {
         Objects.requireNonNull(x, "参数不能为空");
         Staff s = new Staff();
         s.setAge(x);
         return s;
     };
 
     Function<String, Staff> functionC = functionB.compose(functionA);
     Staff staff = functionC.apply(" 我 是 参 数 ！ ");
     // 输出: Staff(name=null, age=5, staffNo=null)
     System.out.println(staff);
 }

  • Function<T, V> andThen(Function<? super R, ? extends V> after： 由两个旧的Function得到一个新的Function。
    假设： 现有式子functionC = functionA.andThen(functionB),functionA泛型为<P1, R1>， functionB泛型为<R1, R2>。
    那么， 上述式子的逻辑是：先运行functionA<P1, R1>的apply方法，然后将其返回值作为functionB<R1, R2>的apply方法的入参，执行functionB<R1, R2>的apply方法，返回一个泛型为<P1, R2>的functionC<P1, R2>。
    注： functionA.andThen(functionB)是先执行functionA，再执行functionB；而functionA.compose(functionB)是先执行functionB，再执行functionA。
    使用示例：

     /**
  * <V> Function<T, V> andThen(Function<? super R, ? extends V> after):由两个旧的Function得到一个新的Function。
  *
  * 假设：现有式子functionC = functionA.andThen(functionB),
  *      functionA泛型为<P1, R1>， functionB泛型为<R1, R2>。
  *
  * 那么，上述式子的逻辑是:先运行functionA<P1, R1>的apply方法，然后将其返回值
  *                     作为functionB<R1, R2>的apply方法的入参，执行
  *                     functionB<R1, R2>的apply方法，返回一个泛型为
  *                     <P1, R2>的functionC<P1, R2>。
  *
  * 注: functionA.andThen(functionB)是先执行functionA，再执行functionB；
  *     而functionA.compose(functionB)是先执行functionB，再执行functionA。
  */
 @Test
 public void test3() {
 
     Function<String, Integer> functionA = x -> {
         Objects.requireNonNull(x, "参数不能为空");
         x = x.replace(" ", "");
         return x.length();
     };
 
     Function<Integer, Staff> functionB = x -> {
         Objects.requireNonNull(x, "参数不能为空");
         Staff s = new Staff();
         s.setAge(x);
         return s;
     };
 
     Function<String, Staff> functionC = functionA.andThen(functionB);
     Staff staff = functionC.apply(" 我 是 参 数 ！ ");
     // 输出: Staff(name=null, age=5, staffNo=null)
     System.out.println(staff);
 }

  • static Function<T, T> identity()： 将输入的参数进行返回，即: return t -> t。
    注： 在某些情景下，使用Function.identity()，会让代码更优雅。
    使用示例：

     /**
  * static <T> Function<T, T> identity(): 将输入的参数进行返回，即: return t -> t。
  *
  * 说明: 在某些情景下，使用Function.identity()，会让代码更优雅。
  */
 @Test
 public void test4() {
     /*
      * 使用普通的lambda表达式
      */
     Map<Integer, String> mapOne = Stream.of("a", "ab", "abc", "abcd", "abcde").collect(
             Collectors.toMap(String::length, param -> param)
     );
     // 输出: {1=a, 2=ab, 3=abc, 4=abcd, 5=abcde}
     System.out.println(mapOne);
 
     /*
      * 使用Function.identity()无疑更优雅
      */
     Map<Integer, String> mapTwo = Stream.of("a", "ab", "abc", "abcd", "abcde").collect(
             Collectors.toMap(String::length, Function.identity())
     );
     // 输出: {1=a, 2=ab, 3=abc, 4=abcd, 5=abcde}
     System.out.println(mapTwo);
 }

IntFunction<R>：

  • R apply(int value)： 入参类型必须为int, (运行相关逻辑后)返回R类型的数据。
    使用示例：
     /**
  * R apply(int value): 入参类型必须为int, (运行相关逻辑后)返回R类型的数据。
  */
 @Test
 public void test5() {
     IntFunction<Staff> intFunction = x -> {
         Staff staff = new Staff();
         staff.setAge(x);
         return staff;
     };
 
     Staff res = intFunction.apply(100);
     // 输出: Staff(name=null, age=100, staffNo=null)
     System.out.println(res);
 }

DoubleFunction<R>：

  • R apply(double value)： 入参类型必须为double，(运行相关逻辑后)返回R类型的数据。
    使用示例：
     /**
  * R apply(double value): 入参类型必须为double, (运行相关逻辑后)返回R类型的数据
  */
 @Test
 public void test6() {
     DoubleFunction<String> doubleFunction = x -> (x + "").replace(".", "_");
     String res = doubleFunction.apply(10.01);
     // 输出: 10_01
     System.out.println(res);
 }

LongFunction<R>：

  • R apply(long value)： 入参类型必须为long, (运行相关逻辑后)返回R类型的数据。

    使用示例：

     /**
  * R apply(long value): 入参类型必须为long, (运行相关逻辑后)返回R类型的数据。
  */
 @Test
 public void test7() {
     LongFunction<String> longFunction = x -> (x + "").replace("4", "  8484884  ").trim();
     String res = longFunction.apply(484);
     // 输出: 8484884  8  8484884
     System.out.println(res);
 }

ToIntFunction<T>：

  • int applyAsInt(T value)： 入参类型为T，(运行相关逻辑后)返回类型必为int。
    使用示例：
     /**
  * int applyAsInt(T value): 入参类型为T, (运行相关逻辑后)返回类型必为int。
  */
 @Test
 public void test8() {
     ToIntFunction<String> toIntFunction = x -> x == null ? 0 : x.length();
     int res = toIntFunction.applyAsInt("蚂蚁呀~嘿！嘿！");
     // 输出: 8
     System.out.println(res);
 }

ToLongFunction<T>：

  • long applyAsLong(T value)： 入参类型为T， (运行相关逻辑后)返回类型必为long。
    使用示例：
     /**
  * long applyAsLong(T value): 入参类型为T, (运行相关逻辑后)返回类型必为long。
  */
 @Test
 public void test9() {
     ToLongFunction<String> toLongFunction = x -> x == null ? 0 : new SecureRandom(x.getBytes()).nextLong();
     long res = toLongFunction.applyAsLong("蚂蚁呀~嘿！嘿！");
     // 输出: 2677168598702751372
     System.out.println(res);
 }

ToDoubleFunction<T>：

  • double applyAsDouble(T value)： 入参类型为T，(运行相关逻辑后)返回类型必为double。
    使用示例：
     /**
  * double applyAsDouble(T value): 入参类型为T, (运行相关逻辑后)返回类型必为double。
  */
 @Test
 public void test10() {
     ToDoubleFunction<Float> toDoubleFunction = x -> x == null ? 0.0 : x;
     double res = toDoubleFunction.applyAsDouble(123.4F);
     // 输出: 123.4000015258789 (注:精度问题不在本文的讨论范围内)
     System.out.println(res);
 }

IntToDoubleFunction：

  • double applyAsDouble(int value)： 入参类型必须为int，(运行相关逻辑后)返回类型必为double。
    使用示例：
     /**
  * double applyAsDouble(int value): 入参类型必须为int, (运行相关逻辑后)返回类型必为double。
  */
 @Test
 public void test11() {
     IntToDoubleFunction intToDoubleFunction = x -> x + 88.8;
     double res = intToDoubleFunction.applyAsDouble(12300);
     // 输出: 12388.8
     System.out.println(res);
 }

IntToLongFunction：

  • long applyAsLong(int value)： 入参类型必须为int，(运行相关逻辑后)返回类型必为long。
    使用示例：
     /**
  * long applyAsLong(int value): 入参类型必须为int, (运行相关逻辑后)返回类型必为long。
  */
 @Test
 public void test12() {
     IntToLongFunction intToLongFunction = x -> x + 1000L;
     long res = intToLongFunction.applyAsLong(12345);
     // 输出: 13345
     System.out.println(res);
 }

LongToDoubleFunction：

  • double applyAsDouble(long value)： 入参类型必须为long， (运行相关逻辑后)返回类型必为double。
    使用示例：
     /**
  * double applyAsDouble(long value): 入参类型必须为long, (运行相关逻辑后)返回类型必为double。
  */
 @Test
 public void test13() {
     LongToDoubleFunction longToDoubleFunction = x -> x + 1000000D;
     double res = longToDoubleFunction.applyAsDouble(12345L);
     // 输出: 1012345.0
     System.out.println(res);
 }

LongToIntFunction：

  • int applyAsInt(long value)： 入参类型必须为long，(运行相关逻辑后)返回类型必为int。
    使用示例：
     /**
  * int applyAsInt(long value): 入参类型必须为long, (运行相关逻辑后)返回类型必为int。
  */
 @Test
 public void test14() {
     LongToIntFunction longToIntFunction = x -> (int)(x / 1000);
     int res = longToIntFunction.applyAsInt(12345L);
     // 输出: 12
     System.out.println(res);
 }

DoubleToIntFunction：

  • int applyAsInt(double value)： 入参类型必须为double，(运行相关逻辑后)返回类型必为int。
    使用示例：
     /**
  * int applyAsInt(double value): 入参类型必须为double, (运行相关逻辑后)返回类型必为int。
  */
 @Test
 public void test15() {
     DoubleToIntFunction doubleToIntFunction = x -> (int)x;
     int res = doubleToIntFunction.applyAsInt(123.45);
     // 输出: 123
     System.out.println(res);
 }

DoubleToLongFunction：

  • long applyAsLong(double value)： 入参类型必须为double，(运行相关逻辑后)返回类型必为long。
    使用示例：
     /**
  * long applyAsLong(double value): 入参类型必须为double, (运行相关逻辑后)返回类型必为long。
  */
 @Test
 public void test16() {
     DoubleToLongFunction doubleToLongFunction = x -> (long)x;
     long res = doubleToLongFunction.applyAsLong(112233.4455);
     // 输出: 112233
     System.out.println(res);
 }

BiFunction<T, U, R>：

  • R apply(T t, U u)： 输入T类型、U类型的参数，运行相关逻辑后，返回R类型的结果。
    使用示例：

     /**
  *  R apply(T t, U u): 输入T类型、U类型的参数，运行相关逻辑后，返回R类型的结果。
  */
 @Test
 public void test17() {
     BiFunction<Integer, String, Staff> biFunction = (x, y) -> {
         Staff s = new Staff();
         s.setAge(x);
         s.setName(y);
         return s;
     };
 
     Staff staff = biFunction.apply(25, "单身邓");
     // 输出: 单身邓, 25岁！
     System.out.println(staff.getName() + ", " + staff.getAge() + "岁！");
 }

  • BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after)： 由一个旧的BiFunction以及一个旧的Function得到一个新的BiFunction<T, U, V>。
    假设： 现有式子biFunctionC = biFunctionA.andThen(functionB),biFunctionA泛型为<P1, T1, R1>， functionB泛型为<R1, R2>。
    那么， 上述式子的逻辑是：先运行biFunctionA<P1, T1, R1>的apply方法，然后将其返回值作为functionB<R1, R2>的apply方法的入参，执行functionB<R1, R2>的apply方法，返回一个泛型为<P1, T1, R2>的biFunctionC<P1, T1, R2>。
    使用示例：

     /**
  * <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after):
  *     由一个旧的BiFunction以及一个旧的Function得到一个新的BiFunction<T, U, V>。
  *
  * 假设：现有式子biFunctionC = biFunctionA.andThen(functionB),
  *      biFunctionA泛型为<P1, T1, R1>， functionB泛型为<R1, R2>。
  *
  * 那么，上述式子的逻辑是:先运行biFunctionA<P1, T1, R1>的apply方法，然后将其返回值
  *                     作为functionB<R1, R2>的apply方法的入参，执行
  *                     functionB<R1, R2>的apply方法，返回一个泛型为
  *                     <P1, T1, R2>的biFunctionC<P1, T1, R2>。
  */
 @Test
 public void test18() {
     BiFunction<Integer, String, Staff> biFunctionA = (x, y) -> {
         Staff s = new Staff();
         s.setAge(x);
         s.setName(y);
         return s;
     };
 
     Function<Staff, Map<String, Staff>> functionB = x -> {
         Map<String, Staff> map = new HashMap<>(4);
         map.put(x.getName(), x);
         return map;
     };
 
     BiFunction<Integer, String,  Map<String, Staff>> biFunctionC = biFunctionA.andThen(functionB);
 
     Map<String, Staff> map = biFunctionC.apply(25, "单身邓");
     // 输出: {单身邓=Staff(name=单身邓, age=25, staffNo=null)}
     System.out.println(map);
 }

ToIntBiFunction<T, U>：

  • int applyAsInt(T t, U u)： 入参类型为T和U，(运行相关逻辑后)返回类型必为int。
    使用示例：
     /**
  * int applyAsInt(T t, U u): 入参类型为T和U, (运行相关逻辑后)返回类型必为int。
  */
 @Test
 public void test19() {
     ToIntBiFunction<String, Double> toIntBiFunction = (x, y) -> Integer.parseInt(x) + y.intValue();
     int res = toIntBiFunction.applyAsInt("123000", 456.789);
     // 输出: 123456
     System.out.println(res);
 }

ToLongBiFunction<T, U>：

  • long applyAsLong(T t, U u)： 入参类型为T和U, (运行相关逻辑后)返回类型必为long。
    使用示例：
     /**
  * long applyAsLong(T t, U u): 入参类型为T和U, (运行相关逻辑后)返回类型必为long。
  */
 @Test
 public void test20() {
     ToLongBiFunction<String, Double> toLongBiFunction = (x, y) -> Integer.parseInt(x) + y.intValue();
     long res = toLongBiFunction.applyAsLong("123000", 456.789);
     // 输出: 123456
     System.out.println(res);
 }

ToDoubleBiFunction<T, U>：

  • double applyAsDouble(T t, U u)： 入参类型为T和U，(运行相关逻辑后)返回类型必为double。
    使用示例：
     /**
  * double applyAsDouble(T t, U u): 入参类型为T和U, (运行相关逻辑后)返回类型必为double。
  */
 @Test
 public void test21() {
     ToDoubleBiFunction<String, Double> toDoubleBiFunction = (x, y) -> Integer.parseInt(x) + y;
     double res = toDoubleBiFunction.applyAsDouble("123000", 456.789);
     // 输出: 123456.789
     System.out.println(res);
 }


^_^ 如有不当之处，欢迎指正

^_^ 参考资料
        《jdk api 1.8_google.CHM》

^_^ 测试代码托管链接
         https://github.com/JustryDeng…Jdk8Feature

^_^ 本文已经被收录进《程序员成长笔记》 ，笔者JustryDeng

justry_deng
关注
  • 8
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JDK1.8【函数式接口】【定义与使用】【源码】
04-19
JDK1.8【函数式接口】【定义与使用】【源码】 文章地址：https://blog.csdn.net/m0_37969197/article/details/124146253 * 函数式接口（类的定义与适应形式，只是一种类的定义形式，属于新增语法） * 包：java.util.function * 条件：接口中 有，且，只有一个，必须实现的抽象方法 * 通过注解检查 @FunctionalInterface进行代码检查提示 * 函数式接口，支持Lambda表达式 也就是说：参数可以长这样 "()->{}" * <p> * JDK1.8内置,四种函数式接口 * 1.消费型 Consumer<T> return：无 * 2.提供型 Supplier<T> return：<T> * 3.函数型 Function<T,R> return：<R> * 4.断言型 Predicate<T> return：boolean * <p> * 参数使用形式 * 形式1：传递函数式接口对象 * 形式2：形参上直接写表达式
JDK1.8函数式接口Function、Consumer、Predicate、Supplier
Agger的博客
11-27 865
JDK1.8函数式接口Function、Consumer、Predicate、Supplier 1. 函数式接口定义 函数式接口（Functional Interface）：有且仅有一个抽象方法的接口，但可以有多个非抽象方法的接口 函数式接口，即适用于函数式编程场景的接口，可以被隐式转换为Lambda表达式来表示接口的一个实现；jdk8以前是使用匿名类实现的。 示例：jdk1.8 使用注解@...
qwen function call 提示词模板
最新发布
awko的博客
05-11 856
【代码】qwen function call 提示词模板， golang + qwen 快速实现大模型函数调用。
jdk1.8之函数式接口
liu_shi_jun的专栏
01-10 1311
jdk1.8 函数式编程之Function , Consumer, Supplier, Predicate
JDK1.8新特性
m0_62946761的博客
05-24 9452
jdk1.8新特性——Lambda表达式，StreamAPi，新时间类，Option，接口内默认方法和静态方法实现
Java 1.8 函数式编程详解
暗余的博客
03-09 2176
Java 1.8 函数式编程详解 文章目录Java 1.8 函数式编程详解一. 概述1.1 java 8 新特性：二. 函数式接口2.1 函数式接口概述2.2 Lambda表达式概述2.3 java.util.function介绍 一. 概述 1.1 java 8 新特性： 概述： Java 8 正式版是一个有重大改变的版本，该版本对 Java 做了重大改进。本文章主要讲述java 1.8 函...
JDK1.8中文文档 JDK1.8中文 jkd8中文文档 JDK中文版
07-15
首先，JDK1.8最重要的新特性之一就是Lambda表达式。Lambda表达式是函数式编程的核心概念，它允许将函数作为一个值传递，简化了代码并提高了可读性。通过这种方式，开发者可以更方便地处理集合数据和编写多线程程序。...
jdk1.8新特性.doc
04-01
JDK1.8引入了许多重要的新特性，极大地提升了Java编程的效率和性能。以下是这些特性的详细介绍： 1、**Lambda表达式**： Lambda表达式是JDK1.8的一个重大改进，它允许开发者以更简洁的方式传递代码块。在上述示例中...
jdk1.8新特性
03-13
JDK1.8新特性简介剖析，仅做参考，希望大家相互学习 作为Comparator 和Runnable早期的证明，在JDK中已经定义的接口恰巧作为函数接口而与lambdas表达式兼容。同样方式可以在你自己的代码中定义任何函数接口或第三方...
jdk1.8 下载。 hotspot (包含源码)
07-17
首先，JDK 1.8中的最大亮点之一是Lambda表达式。Lambda表达式是一种简洁的语法结构，用于表示无主体的匿名函数。它使得编写多线程和处理集合数据变得更加简洁，减少了大量回调函数的使用，提高了代码的可读性和可...
jdk 1.8 中文api文档
12-06
**JDK 1.8** 是Java开发工具集的一个重要里程碑，引入了许多创新特性，提升了Java编程的效率和性能。以下是一些主要的亮点和关键知识点： 1. **Lambda表达式**：JDK 1.8引入了Lambda表达式，这是一种简洁的匿名函数...
jdk1.8新特性学习（四）函数式接口
top_explore的博客
06-09 380
函数式接口 函数式接口是仅包含一个抽象方法的接口，也可以实现一个或者多个默认方法和静态方法。创建函数式接口时，可以使用注解@FunctionalInterface来注解接口，这个注解会帮助我们规范函数式接口。java中提供了四个核心函数式接口： 1.Function函数 Function函数提供了一个apply抽象方法，该方法接收一个参数，并返回一个结果。除此之外，Function还实现了两...
java Lambda语法
chengpeng的博客
08-01 742
Lambda 表达式的基础语法：Java8中引入了一个新的操作符 "-&gt;" 该操作符称为箭头操作符或 Lambda 操作符                               箭头操作符将 Lambda 表达式拆分成两部分：      左侧：Lambda 表达式的参数列表   右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体      语法格式一：无参数，无返回值 ...
JDK8 函数式接口 -干货使用Function 详细讲解快速上手
jjc120074203的博客
09-03 4398
函数式接口 随着JDK 不断升级，大多数企业都采用了JDK1.8 版本 ，函数式接口 也普遍被应用在底层源码中，目前主要和大家分享1.8包中Function、BIFunction 什么是java.util.function.Function包？ Function<T, R>中的Java 8中引入的内置功能接口java.util.function。Function<T, R>...
JDK 1.8 函数接口(收藏用)
一起coding，一起嗨。
02-20 1310
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为 lambda 表达式。Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。
JDK1.8新特性：函数式接口
流楚丶格念的博客
09-26 3169
其实，jdk中给我们提供了很多的函数式接口，我们平时都会用到，只不过大家没有注意到而已，这里我结合实际代码讲解几个常用的函数式接口。Supplier接口的get方法没有入参，返回一个泛型T对象。这个过程是不是有的同学已经发现，怎么这么像jdk里面的一些接口的使用，比如常用的Runnable接口。没错函数式接口，函数式编程，我们可以使用lambda表达式的写法，可以让代码更优雅，具体可以参照我的前一篇帖子。这时，有的同学会说，我用Runnable接口可不是这么用的，我的写法比你优雅，我是这么写的。
JDK1.8新特性--函数式接口(详解)
健身变秃，coding变强
11-08 2609
主要内容: 1: 自定义函数式接口 2: 函数式编程 3: 常用函数式接口 3.1 Supplier 你要作为一个供应者,自己生产数据 3.2 Consumer 你要作为一个消费者,利用已经准备数据 3.3 Function 输入一个或者两个不同或者相同的值转为另一个值 3.4 Predicate 输入一个或者两个不同或者相同的值总是输出boolean 3.5 UnaryOperator 输入一个值转换为相同值输出 3.6 BinaryOperator 输入两个相同类型的值 转为相同类型的值输出 主要语法
JDK1.8中函数式编程
奇点
12-08 968
Function接⼝的使⽤ Lambda表达式必须先定义接⼝，创建相关⽅法之后才可使⽤，这样做⼗分不便，其实java8已经 内置了许多接⼝, 例如下⾯四个功能型接⼝，所以⼀般很少会由⽤户去定义新的函数式接⼝ Java8的最⼤特性就是函数式接⼝，所有标注了@FunctionalInterface注解的接⼝都是函数式接⼝ Java8 内置的四⼤核⼼函数式接⼝ Consumer<T> ...
jdk1.8特性详解
10-08
引用: JDK 1.8引入了许多新的特性，其中包括Lambda表达式、函数式接口、方法引用、Stream流等。Lambda表达式是一种简洁的写法，可以用于代替匿名内部类。函数式接口是只包含一个抽象方法的接口，可以用Lambda表达式来实现。方法引用是一种简化方法调用的方式。Stream流是一种新的处理数据集合的方式，可以进行过滤、映射、排序等操作。这些特性的引入使得Java编程更加简洁、灵活和高效。 引用: 在JDK 1.8中，新增了Consumer接口，它是一个消费性函数式接口，用于接收一个参数并执行操作，没有返回值。可以通过Lambda表达式来实现Consumer接口的抽象方法。另外，还有Supplier接口，它是一个供给型函数式接口，用于在无参情况下提供一个返回值。Funcation接口是一个函数型函数式接口，用于接收一个参数并产生一个结果。 在使用这些函数式接口时，可以通过Lambda表达式快速定义接口的抽象方法实现，并将其作为参数传递给相应的方法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值