JAVA基础深化提高(九) | 函数式编程

已于 2023-08-21 18:38:50 修改
阅读量33 收藏
点赞数
分类专栏： Java 文章标签： java
于 2023-08-06 10:13:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65180200/article/details/132123528
版权

一、Lambda表达式介绍

1.1 Lambda简介

Lambda表达式是Java 8引入的一种新特性，用于简化代码编写和提高代码可读性。它允许我们以更简洁的方式定义和传递匿名函数。

Lambda表达式由箭头"->"分隔为两部分：左侧为参数列表，右侧为表达式主体。它通常用于替代需实现函数式接口的匿名内部类。

Lambda表达式具有以下特点：

  1. 简洁性：Lambda表达式可以极大地减少冗余的代码，使得程序更加精简和易读。
  2. 函数式编程：Lambda表达式鼓励使用函数式编程思想，通过将函数视为第一等公民来处理数据和逻辑。
  3. 延迟执行：Lambda表达式允许延迟执行代码，比如在需要的时候才进行计算或处理。

Lambda表达式的应用场景包括但不限于：

  1. 集合操作：可以通过Lambda表达式对集合进行遍历、过滤和转换等操作。
  2. 多线程编程：可以将Lambda表达式作为线程任务，简化多线程编程的代码量。
  3. 排序和比较：可以通过Lambda表达式定义自定义的排序规则和比较器。

Lambda表达式的语法形式可以灵活运用，适应不同的需求和场景。它是现代Java编程中的重要工具，使代码更加简洁、灵活和易于维护。

1.2 接口要求

虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法。

jdk 8 中有另一个新特性：default， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。

@FunctionalInterface注解作用

@FunctionalInterface标记在接口上，“函数式接口”是指仅仅只包含
一个抽象方法的接口。

二、Lambda表达式语法

2.1 语法结构

(parameters) -> expression
或
(parameters) ->{ statements;}

语法形式为 () -> {}：

() 用来描述参数列表，如果有多个参数，参数之间用逗号隔开，如果没有参数，留空即可；

-> 读作(goes to)，为 lambda运算符 ，固定写法，代表指向动作；

{} 代码块，具体要做的事情，也就是方法体内容；

2.2 Lambda表达式的重要特征

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

2.3 Lambda案例

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

三、Lambda表达式入门案例

3.1 定义函数接口

/**
 * 无返回值，无参数
 */
@FunctionalInterface
interface NoReturnNoParam{
    void method();
}

/**
 * 无返回值，有一个参数
 */
@FunctionalInterface
interface NoReturnOneParam{
    void method(int a);
}

/**
 * 无返回值，有多个参数
 */
@FunctionalInterface
interface NoReturnMultiParam{
    void method(int a,int b);
}

/**
 * 有返回值，无参数
 */
@FunctionalInterface
interface ReturnNoParam{
    int method();
}

/**
 * 有返回值，有一个参数
 */
@FunctionalInterface
interface ReturnOneParam{
    int method(int a);
}


/**
 * 有返回值，有多个参数
 */
@FunctionalInterface
interface ReturnMultiParam{
    int method(int a ,int b);
}

3.2 实现函数接口

 public static void main(String[] args) {
        /**
         * 无返回值，无参数
         */
       /* NoReturnNoParam noReturnNoParam= ()->{
            System.out.println("NoReturnNoParam");
        };*/
        /**
         * 简化版
         */
        NoReturnNoParam noReturnNoParam=()-> System.out.println("NoReturnNoParam");
        noReturnNoParam.method();

        /**
         * 无返回值，有一个参数
         */
      /*  NoReturnOneParam noReturnOneParam = (int a)->{
            System.out.println("NoReturnOneParam "+a);
        };*/
        /**
         * 简化版
         */
        NoReturnOneParam noReturnOneParam = a -> System.out.println("NoReturnOneParam "+a);

        noReturnOneParam.method(10);


        /**
         * 无返回值，有多个参数
         */
       /* NoReturnMultiParam noReturnMultiParam= (int a,int b)->{
            System.out.println("NoReturnMultiParam "+a+"\t"+b);
        };*/
        /**
         * 简化版
         */
        NoReturnMultiParam noReturnMultiParam=(a,b)->System.out.println("NoReturnMultiParam "+a+"\t"+b);
        noReturnMultiParam.method(10,20);


        /**
         * 有返回值，无参数
         */
       /* ReturnNoParam returnNoParam = ()->{
            System.out.print("ReturnNoParam ");
            return 10;
        };*/

        /**
         * 简化版
         */
        ReturnNoParam returnNoParam =()->10;
        System.out.println(returnNoParam.method());

        /**
         * 有返回值，有一个参数
         */
        /*ReturnOneParam returnOneParam = (int a)->{
            System.out.print("ReturnOneParam ");
            return a;
        };*/
        /**
         * 简化版
         */
        ReturnOneParam returnOneParam = a -> a;
        System.out.println(returnOneParam.method(10));

        /**
         * 有返回值，有多个参数
         */
        /*ReturnMultiParam returnMultiParam = (int a,int b)->{
            System.out.print("ReturnMultiParam ");
            return a+b;
        };*/
        /**
         * 简化版
         */
        ReturnMultiParam returnMultiParam = (a,b) -> a+b;

        System.out.println(returnMultiParam.method(10,20));
    }

四、Lambda表达式的使用

4.1 Lambda表达式的引用方法

4.1.1 要求

  • 参数的个数以及类型需要与函数接口中的抽象方法一致。
  • 返回值类型要与函数接口中的抽象方法的返回值类型一致。

4.1.2 语法

方法归属者::方法名 静态方法的归属者为类名，非静态方法归属者为该对象的引用。

4.1.3 案例

 	/**
     * 要求：
     * 1,参数的个数以及类型需要与函数接口中的抽象方法一致。
     * 2,返回值类型要与函数接口中的抽象方法的返回值类型一致。
     * @param a
     * @return
     */

  public static int doubleNum(int a){
        return 2*a;
  }
  public int addTwo(int a){
       return a+2;
  }

public class Test2 {
    public static void main(String[] args) {
        ReturnOneParam returnOneParam = Test::doubleNum;
        int value  = returnOneParam.method(10);
        System.out.println(value);
        Test test = new Test();
        ReturnOneParam returnOneParam1 = test::addTwo;
        int value1 = returnOneParam1.method(10);
        System.out.println(value1);
    }
}

4.2 Lambda表达式创建线程

public class Test3 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+" 开始");
        new Thread(()->{
            for(int i=0;i<20;i++){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+" "+i);
            }
        },"Lambda Thread").start();

        System.out.println(Thread.currentThread().getName()+" 结束");
    }
}

4.3 Lambda 表达式中的闭包问题

4.3.1 什么是闭包

闭包的本质就是代码片断。所以闭包可以理解成一个代码片断的引用。在Java中匿名内部类也是闭包的一种实现方式。

在闭包中访问外部的变量时，外部变量必须是final类型，虚拟机会帮我们加上 final 修饰关键字。

public class Test4 {
    public static void main(String[] args) {
        final int num = 10;
        NoReturnNoParam noReturnNoParam = ()-> System.out.println(num);
        noReturnNoParam.method();
    }
}

五、常用的函数接口

5.1 Consumer接口的使用

Consumer 接口是JDK为我们提供的一个函数式接口，该接口也被称为消费型接口。

5.1.1 遍历集合

我们可以调用集合的 public void forEach(Consumer<? super E> action) 方法，通过 lambda 表达式的方式遍历集合中的元素。以下是 Consumer 接口的方法以及遍历集合的操作。

public class Test5 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.forEach(System.out::println);
    }

    //格式化数字的函数式方法
    public void f1(Consumer<Double> c, Double money) {
        c.accept(money);
    }

    @Test
    public void f1Test() {
        f1(c -> {
            DecimalFormat df = new DecimalFormat("#,###.###");//格式化数字，不保留0
            System.out.println(df.format(c));
        }, 123459687978.78966);
        System.out.println("-----------------------------------------------");
        f1(c -> {
            DecimalFormat df = new DecimalFormat("0,000.000");//格式化数字,可以保留0
            System.out.println(df.format(c));
        }, 123459687978.78966);
    }
}

在这里插入图片描述

5.2 Predicate接口的使用

Predicate 是 JDK 为我们提供的一个函数式接口，可以简化程序的编写。

5.2.1 删除集合中的元素

我们通过public boolean removeIf(Predicate<? super E> filter)方法来删除集合中的某个元素，

class PredicateImpl implements Predicate{

    @Override
    public boolean test(Object o) {
        return (o.equals("b"));
    }
}
public class Test6 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        list.removeIf(ele->ele.equals("a"));
        list.forEach(System.out::println);
    }
    /**
     * 根据指定规则过滤集合中的的信息然后返回一个过滤后的集合
     */
    @Test
    public void filterListTest(){
        List<String> list = new ArrayList<>();
        list.add("hello abc");
        list.add("welcome abc");
        list.add("hello world");
        list.add("你好 abc");
        list.add("大家好 abc");
        list.add("hello mickey");
        list.stream().filter(s -> s.contains("hello")).collect(Collectors.toList()).forEach(System.out::println);
    }
}

5.3 Comparator接口的使用

Comparator是 JDK 为我们提供的一个函数式接口，该接口为比较器接口。

5.3.1 元素排序

class ComparatorImpl implements Comparator<String>{
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
}

public class Test7 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");

        list.sort((o1,o2)->o1.compareTo(o2));
        list.forEach(System.out::println);
        System.out.println("-----------------");

        //引用类方法
        list.sort(String::compareTo);
        list.forEach(System.out::println);
        System.out.println("-----------------");

        //使用Comparator接口中的naturalOrder方法做升序排序。
        list.sort(Comparator.naturalOrder());
        list.forEach(System.out::println);
        System.out.println("-----------------");

        //使用Comparator接口中的naturalOrder方法做升序排序。
        list.sort(Comparator.reverseOrder());
        list.forEach(System.out::println);
        System.out.println("-----------------");
    }
}

六、Stream流介绍

6.1 Stream流简介

Stream是数据渠道，用于操作数据源所生成的元素序列，它可以实现对集合的复杂操作，例如过滤、排序和映射等。Stream不会改变源对象，而是返回一个新的结果集。

6.2 Stream流的生成方式

  • 生成流：通过数据源（集合、数组等）创建一个流。
  • 中间操作：一个流后面可以跟随零个或者多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用。
  • 终结操作：一旦执行终止操作，就执行中间的链式操作，并产生结果。

6.3 Stream流的常见方法

6.3.1 数据过滤

public class Test8 {
    public static void main(String[] args) {
        /**
         * 1.创建Stream对象
         * 2.操作Stream对象
         * 3.结束Stream对象
         */

        List<String> list = new ArrayList<>();
        list.add("oldlu");
        list.add("oldlin");
        list.add("kevin");
        list.add("peter");




        //多条件的and关系
      list.stream().filter(ele->ele.startsWith("o")).filter(ele->ele.endsWith("n")).collect(Collectors.toList()).forEach(System.out::println);
        System.out.println("------------------");

        //多条件的or关系
        Predicate<String> predicate1 = ele->ele.startsWith("o");
        Predicate<String> predicate2 = ele-> ele.endsWith("n");
        list.stream().filter(predicate1.or(predicate2)).collect(Collectors.toList()).forEach(System.out::println);
    }

	//函数式接口过滤求和
    @Test
    public void f1(){
        List<User> list = new ArrayList<>();
        list.add(new User(1, "mickey", 18));
        list.add(new User(2, "john", 18));
        list.add(new User(3, "doc", 18));
        list.add(new User(4, "cat", 18));
        list.add(new User(5, "tom", 18));
        list.add(new User(6, "tomcat", 18));
        list.add(new User(7, "mysql", 18));
        list.add(new User(8, "java", 18));
        System.out.println(list.stream().map(user -> user.getAge()).reduce((d1, d2) -> d1 + d2).get());
    }

    @Test
    public void f2(){
        List<User> list = new ArrayList<>();
        list.add(new User(1, "amickey", 22));
        list.add(new User(2, "johna", 33));
        list.add(new User(3, "doca", 19));
        list.add(new User(4, "cat", 20));
        list.add(new User(5, "toma", 20));
        list.add(new User(6, "tomcat", 70));
        list.add(new User(7, "mysqla", 73));
        list.add(new User(8, "java", 84));
        //查看user集合中的名字中是否都包含 a  包含返回true 反之false 
        System.out.println(list.stream().allMatch(user -> user.getMickey().contains("a")));
    }

    @Test
    public void test3() {
        //以()代表流，[]为数组，""为字符串
        List<String> list = Arrays.asList("a-b-c", "d-e-f");

        //map中的第一个t是"a-b-c",返回的是[a,b,c]一个数组
        //map以后流中的元素为([a,b,c],[e,d,f])两个元素，每个元素是数组
        //map: ("a-b-c", "d-e-f")---->([a,b,c],[e,d,f]) ,size=2
        list.stream().map(t -> t.split("-")).forEach(e -> System.out.println(Arrays.toString(e)));

        System.out.println("-----------");

        //flatMap第一个t是"a-b-c",返回的是(a,b,c)的一个子流，最后聚合所有子流合并为一个流
        //flatMap: ("a-b-c", "d-e-f")---->((a,b,c),(d,e,f))-->(a,b,c,d,e,f) ,size=6
        list.stream().flatMap(t -> Stream.of(t.split("-"))).forEach(System.out::println);
    }
}

6.3.2 数量限制

public class Test9 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("oldlu");
        list.add("oldlin");
        list.add("kevin");
        list.add("peter");
        list.stream().limit(2).collect(Collectors.toList()).forEach(System.out::println);
    }
}

6.3.3 元素排序

public class Test10 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("b");
        list.add("c");
        list.add("a");
        list.add("d");

        //升序排序
        list.stream().sorted().forEach(System.out::println);
        System.out.println("----------------------");
        list.stream().sorted(Comparator.naturalOrder()).forEach(System.out::println);

        System.out.println("----------------------");
        //降序排序
        list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);
    }

 	@Test
    public void f1(){
        List<User> list = new ArrayList<>();
        list.add(new User(1, "mickey", 22));
        list.add(new User(2, "john", 33));
        list.add(new User(3, "doc", 19));
        list.add(new User(4, "cat", 20));
        list.add(new User(5, "tom", 20));
        list.add(new User(6, "tomcat", 70));
        list.add(new User(7, "mysql", 73));
        list.add(new User(8, "java", 84));
        list.stream().sorted((o1,o2)->Integer.compare(o1.getAge(),o2.getAge())).collect(Collectors.toList()).forEach(System.out::println);
    }
}
惊鸿化雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第二阶段：JAVA基础深化与提高
SCORPICAT的博客
02-27 1027
文章目录2 第二阶段 JAVA深化和提高2.1 面向对象深化2.1.1 抽象类和抽象方法2.1.1.1 抽象方法概念2.1.1.2 什么情况下使用抽象方法和抽象类？2.1.2 接口详解2.1.2.1 接口的概念2.1.2.2 接口中可以包含什么？2.1.2.3 接口与类的关系2.1.3 接口的特征_使用接口的意义2.1.3.1 接口的传递性2.1.3.2 接口的继承性（多继承）2.1.3.3 使用...
Java-Java函数式编程教程
11-14
Java 函数式编程教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
Java基础深化和提高 ---- 函数式编程 Lambda
11-22 238
在Java 8里面，所有的Lambda的类型都是一个接口，而Lambda表 达式本身，也就是”那段代码“，需要是这个接口的实现。这是我认 为理解Lambda的一个关键所在，简而言之就是，Lambda表达式本 身就是一个接口的实现。直接这样说可能还是有点让人困扰，我们 继续看看例子。我们给上面的aBlockOfCode加上一个类型：
JAVA基础深化提高(五) | 容器
weixin_65180200的博客
07-27 130
在本篇博客中，我们将深入讨论Java中的容器。容器是一种用于存储和组织对象的数据结构，包括常见的列表、集合和映射。我们将介绍ArrayList和LinkedList等列表实现类，了解它们的特点和用法。接着，我们将探究HashSet和TreeSet等集合实现类，学习如何使用它们进行元素的唯一性和排序。此外，我们还将研究HashMap和TreeMap等映射实现类，了解如何存储键值对并进行高效的查找。除了这些基本容器，我们还会介绍如何自定义容器类。通过掌握容器的概念和使用方法，您将能够更好地管理和操作数据，并提高
Java基础深化和提高 ---- 网络编程
11-21 871
通过计算机网络可以实现不同计算机之间的连接与通信，但是计算 机网络中实现通信必须有一些约定即通信协议，对速率、传输代 码、代码结构、传输控制步骤、出错控制等制定标准。国际标准化组织(ISO，即International Organization for Standardization)定义了网络通信协议的基本框架，被称为OSI （Open System Interconnect，即开放系统互联）模型。
JAVA 基础深化和提高【上】
LiLi的博客
02-19 690
异常机制 导引问题 工作中，程序遇到的情况不可能完美。比如：程序要打开某个文件，这个文件可能不存在或者文件格式不对；程序在运行着，但是内存或硬盘可能满了等等。 软件程序在运行过程中，非常可能遇到刚刚提到的这些问题，我们称之为异常，英文是：Exception，意思是例外。遇到这些例外情况，或者叫异常，我们怎么让写的程序做出合理的处理，安全的退出，而不至于程序崩溃呢？我们这里就要讲解这些问题。 如果我们要拷贝一个文件，在没有异常机制的情况下，我们需要考虑各种异常情况，伪代码如下： 【示例】伪代码：使用 i
JAVA基础深化提高(六) | 多线程和并发编程
weixin_65180200的博客
08-01 93
多线程和并发编程是计算机科学领域中的重要主题，它涉及到同时执行多个任务以提高程序性能和效率的概念和技术。这篇博客旨在深化和提高读者对JAVA多线程和并发编程的理解。 首先，博客将介绍多线程的基本概念和原理。它将讨论线程的创建和管理，包括使用Thread类和实现Runnable接口来创建线程，并且引导读者了解如何有效地调度和控制线程的执行。 其次，博客将探讨线程同步和互斥的概念。读者将学习如何处理多线程环境中的竞态条件和资源冲突问题，并深入了解如何使用synchronized关键字和Lock接口来实现线程
Java基础深化和提高-------容器篇
06-11 307
容器，是用来容纳物体、管理物体。生活中,我们会用到各种各样的容器。如锅碗瓢盆、箱子和包等。程序中的“容器”也有类似的功能，用来容纳和管理数据。比如，如下新闻网站的新闻列表、教育网站的课程列表就是用“容器”来管理：开发和学习中需要时刻和数据打交道，如何组织这些数据是我们编程中重要的内容。我们一般通过“容器”来容纳和管理数据。事实上，我们前面所学的数组就是一种容器，可以在其中放置对象或基本类型数据。数组的优势：是一种简单的线性序列，可以快速地访问数组元素，效率高。
Apache Beam中的函数式编程理念
weixin_34198583的博客
09-29 47
    　　不多说，直接上干货！     Apache Beam中的函数式编程理念　　Apache Beam的编程范式借鉴了函数式编程的概念，从工程和实现角度向命令式妥协。 　　编程的领域里有三大流派：函数式、命令式、逻辑式。 　　此处的函数不是编程语言中的函数，而是数学中的函数。现代计算的理论模型是图灵机，冯诺依曼体系是图灵机的实现，所以命令式变成本质上是冯诺依曼...
《编程机制探析》第十七章 函数式编程
专注美食
08-29 132
有熟练掌握递归，我们还是可以向函数式进军。我们可以在学习函数式编程的过程中，逐步习惯递归的写法。 函数式编程并非主流编程模型，函数式语言亦非主流编程语言。但我们在描述某些具体问题时，不可避免地要涉及到一些代码。本书会尽量选择有代表性的函数式语言。本书的选择是Haskell和ErLang这两门函数式语言。 Haskell是一门学术性很强的、特性很全面、形式很正规的函数式语言，很适合用来描述函数式编程的一些重要核心概念。因此，Haskell是一种常见的教学语言。本书也不能免俗。 ErLang是一门比较实用
基础深化和提高-java函数式编程
11-11
Java函数式编程是指利用函数式编程的思想和特性来开发Java应用程序。函数式编程强调将计算过程视为数学函数的求值，侧重于函数的组合、映射、过滤等操作，同时避免了可变状态和可变数据。 在Java中，函数式编程主要...
Java 8函数式编程.pdf
08-12
Java 8函数式编程
详解JAVA 函数式编程
08-18
主要介绍了JAVA 函数式编程的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
java函数式编程入门
12-21
以前写过一篇java8的流操作，人们都说流操作是函数式编程，但函数式编程是什么呢？ 什么是函数式编程 什么是函数式编程？它是一种编程范式，即一切都是数学函数。函数式编程语言里也可以有对象，但通常这些对象都是...
jar包增量更新分析
junlaiyan的专栏
05-16 256
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 674
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 618
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 905
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
java 函数式编程
09-20
函数式编程是一种编程范式，它将计算过程看作是一...通过使用Lambda表达式和Java的函数式接口，我们可以以更简洁、灵活和可读性更强的方式编写函数式代码，并且可以利用Java内置的函数式接口来处理各种函数式编程场景。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值