Java：函数式编程

最新推荐文章于 2024-07-23 15:58:39 发布

拾荒追逐者

最新推荐文章于 2024-07-23 15:58:39 发布

阅读量190

点赞数

分类专栏： Java技术文章标签： java lambda

本文链接：https://blog.csdn.net/u012510831/article/details/106609189

版权

Java技术专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. 函数式编程思想

函数式编程体现的是一种编程思想，是面向数学的抽象，通过表达式将原数据映射为新的数据。

2. 为什么使用函数式编程

一个例子告诉你为什么使用函数式编程：将一个数组中的每个元素求平方，这段代码应该怎么写？

实现方案1


  public static void squareTest1(){

        List<Integer> list = Arrays.asList(1,2,3,4,5);
        //创建一个新集合
        List<Integer> retList = new ArrayList<>();
        //遍历旧集合
        for(Integer element : list){
           //将元素计算后添加到新集合中
           retList.add(element * element);
        }
        //循环输出
        for(Integer element : retList){

            System.out.println(element);
        }
    }

实现方案2


 public static void squareTest2(){

        List<Integer> list = Arrays.asList(1,2,3,4,5);

        //把集合中的元素映射到新的集合中
        List<Integer> retList = list.stream().map((e)->e*e).collect(Collectors.toList());
        
        //对每一个元素执行输出操作
        retList.stream().forEach((e)->System.out.println(e));
    }

总结：方案将待求解的问题转换为一个个命令，然后依次执行命令，最终得到结果，这是一种典型的命令式编程方式。面向对象的编程方式是命令式编程的一种。方案2，通过一个表达式，将原集合元素映射到新的集合，简单明了，这种编程方式就是函数式编程。

3. 函数式编程了解哪些

3.1 lambda表达式

3.1.1 什么是lambda表达式

什么是lambda表达式？形如：(参数1，参数2…)->{//代码块}的一段代码。

3.1.2 如何写lambda表达式

如定义一个函数，这个函数接收一个整型数据和一个计算接口为入参，根据计算接口计算最终结果，代码如下：

     /**
     * 计算接口
     */
    interface Calculate{

       Integer calc(Integer a);

    }

    private static Integer calc(Integer a,Calculate calculate){

        return calculate.calc(a);
    }
    
    public static void interfaceTest(){

        Integer ret = calc(10, new Calculate() {

            @Override
            public Integer calc(Integer a) {

                return a*a;
            }
        });

        System.out.println(ret);
    }

    public static void lambdaTest(){

        //lambda表达式
        Integer ret = calc(10, (e)->e*e);

        System.out.println(ret);
    }

3.1.3 lambda表达式注意事项

使用lambda表达式后代码非常简洁，可以让我们更聚焦于业务逻辑的编写。那么，lambda表达式怎么知道我的接口类型为Calculate的？答案是：编译器的类型推导，编译器会将lambda表达式转换为正确的类型。再看上面的例子，如果Calculate接口有不止一个方法会怎么样？

   /**
     * 计算接口
     */
    interface Calculate{

       Integer calc(Integer a);

       //添加一个接口
       Integer test(Integer a);

    }

此时再用lambda表达式，会收到编译器的报错，说明什么？lambda表达式可替换的接口只能有一个方法，没错，这种接口就是函数式接口。

3.2 函数式接口

3.2.1 什么是函数式接口

函数式接口就是只有一个抽象方法的接口，Java中如何约束一个接口是函数式接口？使用注解：@FunctionalInterface，示例如下：


@FunctionalInterface
interface Calculate{

   Integer calc(Integer a);

}

3.2.2 供lambda表达式使用的函数式接口

3.2.2.1 Predicate接口

Predicate 接口只有一个参数，返回boolean类型。形如：该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。示例代码：


Predicate<Integer> predicate = (e)->e>10;

predicate.and((e) -> e > 20).test(15);//false

predicate.or((e) -> e > 20).test(15);//true

3.2.2.2 Function 接口

Function 接口有一个参数并且返回一个结果，并附带了一些可以和其他函数组合的默认方法（compose, andThen）。示例代码：

Function<String,Integer> function = (T)->Integer.parseInt(T);
        
function.apply("123");//123
function.andThen((T)->T+100).apply("123");//223

3.2.2.3 Supplier 接口

Supplier 接口返回一个任意泛型的值，和Function接口不同的是该接口没有任何参数。示例代码：

 Supplier<String> supplier = ()->"123";

 supplier.get(); //"123"

3.2.2.4 Consumer 接口

Consumer 接口表示执行在单个参数上的操作。示例代码：

Consumer<String> consumer = (e)->System.out.println(e);

 consumer.accept("123");//打印"123"

3.3 Stream

3.3.1 Java中的流

Java流使程序员得以站在更高的抽象层次上对集合进行操作。

我们先看一个例子，一个集合中有10个整型元素，我们要从中过滤掉偶数元素，只保留奇数元素，代码怎么写？


public static void filterTest(){

    List<Integer> list = Arrays.asList(1,3,5,8,10,13,7,39,28,53);
    
    //一行代码搞定
    List<Integer> newList = list.stream().filter((e)->e%2==1).collect(Collectors.toList());

    newList.forEach((e)->System.out.println(e));
}