AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

函数式编程概念和应用

2022-09-24 218
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 函数式编程的核心要素：传入参数，执行逻辑，返回值，也可以没有返回值。函数式的编程风格侧重描述程序的执行逻辑，不是执行过程。

一、函数式概念

函数式编程是一种结构化编程的范式，主要思想是把运算过程尽量写成系列嵌套的函数调用。函数编程的概念表述带有很抽象的感觉，可以基于案例看：

public class Function01 {
    public static void main(String[] args) {
        // 运算：（x+y）* c
        int x1 = 2 ;
        int y1 = 3 ;
        int c1 = 4 ;
        int sum1 = x1 + y1 ;
        int res1 = sum1 * c1 ;
        System.out.println("res1 = "+res1);
    }
}

这里基于过程的方式做计算，上面的代码块着重在描述程序执行过程。

在看基于函数的方式解决方法：

public class Function02 {
    public static void main(String[] args) {
        // 函数式计算
        System.out.println("func01 = "+func01(2,3,4));
    }
    private static int func01 (int x,int y,int c){
        return (x+y)*c;
    }
}

函数式编程的核心要素：传入参数，执行逻辑，返回值，也可以没有返回值。

函数式的编程风格侧重描述程序的执行逻辑，不是执行过程。

同上面计算过程相比，函数式编程也减少很多临时变量的创建，代码风格也变的简洁清楚。

二、函数与方法

在Java语言中有函数式编程风格，但是Java代码中没有函数的说法，而是称为：方法；

public class Function03 {
    public static void main(String[] args) {
        Func03 func03 = new Func03();
        func03.add(2);
        System.out.println(func03.res1);
    }
}
class Func03 {
    public int res1 = 0 ;
    public void add (int a1){
        this.res1 = a1 +1 ;
    }
}

类定义引用数据类型，类实例化后的对象可以调用类内部的方法和数据，这是最直观的感觉。

但是方法又有静态和非静态的区别，静态方法属于类所有，类实例化前即可使用。

非静态方法可以访问类中的任何成员变量和方法，并且必须是类实例化后的对象才可以调用。

三、JDK函数基础

1、Lambda表达式

Lambda表达式也可称为闭包，是推动Java8发布的最重要新特性，允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

这里就很鲜明的对比Lambda表达式语法和传统用法。

public class Lambda01 {
    interface LambdaOpera {
        int operation(int a, int b);
    }
    public static void main(String[] args) {
        LambdaOpera lambdaOpera = new LambdaOpera(){
            @Override
            public int operation(int a, int b) {
                return a * b ;
            }
        };
        System.out.println(lambdaOpera.operation(3,2));
        LambdaOpera lambdaOpera01 = (int a, int b) -> a + b;
        LambdaOpera lambdaOpera02 = (int a, int b) -> a - b;
        System.out.println(lambdaOpera01.operation(3,2));
        System.out.println(lambdaOpera02.operation(3,2));
    }
}

在看一个直观的应用案例，基于Lambda的方式创建线程，可以使代码变的更加简洁紧凑:

public class Lambda02 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 2; i++) {
                    System.out.println(i);
                }
            }
        }).start();
        // 对比 Lambda 方式
        new Thread(() -> {
            for (int i = 0; i < 2; i++) {
                System.out.println(i);
            }
        }).start();
    }
}

在看一下Runnable接口的结构：

FunctionalInterface标记在接口上，表示该接口是函数式接口，并且该接口只包含一个抽象方法，

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Lambda表达式本身可以理解为就是一个接口的实现过程，这里runnable就是完整的Lambda表达式声明：

public class Lambda04 {
    public static void main(String[] args) {
        Runnable runnable = () -> {
            System.out.println("run one...");
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

Lambda表达式最直观的作用就是使得代码变得异常简洁，并且可以作为参数传递。

2、函数式接口

Lambda表达式虽然有很多优点，但是使用的时候需要定义一些接口用来完成编码，这样又使得表达式又变得重量级，Java8自身已经提供几个常见的函数式接口。

  • Function：输入一个参数，返回一个结果；
  • Consumer：输入一个参数，不返回结果；
  • BiFunction：输入两个参数，返回一个结果；
  • BiConsumer：输入两个参数，不返回任何结果；
public class Lambda05 {
    public static void main(String[] args) {
        Function<Integer, Integer> function01 = x -> x * 2;
        System.out.println(function01.apply(2));
        BiFunction<Integer, Integer, Integer> function02 = (x, y) -> x * y;
        System.out.println(function02.apply(2, 3));

        Consumer<String> consumer01 = msg -> System.out.println("msg:"+msg);
        consumer01.accept("hello");

        BiConsumer<String,Integer> consumer02 = (msg,i)
                -> System.out.println(msg+":"+i);
        consumer02.accept("world",3);
    }
}

如果面对更复杂的业务需求，可以自定义函数式接口去解决。

四、Optional类

1、Null判断

Optional类是Java函数式编程的应用，主要用来解决常见的空指针异常问题。

在Java编程的开发中，很多地方都能常见空指针异常的抛出，如果想避免这个问题就要加入很多判断：

public class Optional01 {
    public static void main(String[] args) {
        User user = new User(1,"hello") ;
        if (user != null){
            if (user.getName() != null){
                System.out.println(user.getName());
            }
        }
    }
}

为了确保程序不抛出空指针这种低级的错误，在程序中随处可以null的判断，代码显然冗余和繁杂。

2、Optional应用

基于Optional类创建的对象可能包含空值和null值，也同样会抛出对应的异常：

public class Optional02 {
    public static void main(String[] args) {
        // NoSuchElementException
        Optional<User> optionalUser = Optional.empty();
        optionalUser.get();
        // NullPointerException
        Optional<User> nullOpt = Optional.of(null);
        nullOpt.get();
    }
}

所以在不明确对象的具体情况下，使用ofNullable()方法:

public class Optional03 {
    public static void main(String[] args) {
        User user = new User(1,"say");
        Optional<User> optionalUser = Optional.ofNullable(user);
        if (optionalUser.isPresent()){
            System.out.println(optionalUser.get().getName());
        }
        User user1 = null ;
        User createUser = Optional.ofNullable(user1).orElse(createUser());
        System.out.println(createUser.getName());
        User user2 = null ;
        Optional.ofNullable(user2).orElseThrow( ()
                -> new RuntimeException());;
    }
    public static User createUser (){
        return new User(2,"hello") ;
    }
}

这样看下来Optional结合链式方法和Lambda表达式就很大程度上简化了应用的代码量：

public class Optional04 {
    public static void main(String[] args) {
        // 1、map转换方法
        User user = new User(99, "Java");
        // user = null ;
        String name = Optional.ofNullable(user)
                .map(u -> u.getName()).orElse("c++");
        System.out.println(name);
        // 2、过滤方法
        Optional<User> optUser01 = Optional.ofNullable(user)
                .filter(u -> u.getName() != null && u.getName().contains("c++"));
        // NoSuchElementException
        System.out.println(optUser01.get().getName());
    }
}

Optional提供null处理的各种方法，可以简洁很多代码判断，但是在使用风格上和之前变化很大。

五、Stream流

如果Optional简化很多Null的判断，那Stream流的API则简化了很多集合的遍历判断，同样也是基于函数式编程。

08-1.png

上述为Stream接口继承关系如图，同样提供一些特定接口和较大的包装接口，通过源码查看，可以看到和函数编程也是密切相关。

public class Stream01 {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("hello", "java");
        stream.forEach(str -> System.out.print(str+";"));
    }
}

Stream与函数接口结合使用，函数接口又可以使用Lambda表达式进行简化代码。在Java8通过Stream可以大量简化集合使用的代码复杂度。

public class Stream02 {
    public static void main(String[] args) {
        // 1、转换Stream
        List<String> list = Arrays.asList("java+；", "c++；", "net；");
        list.stream();
        // 2、forEach操作
        list.stream().forEach(System.out::print);
        // 3、map映射，输出 3，4
        IntStream.rangeClosed(2,3).map(x->x+1).forEach(System.out::println);
        // 4、filter过滤
        list.stream().filter(str -> str.contains("+")).forEach(System.out::print);
        // 5、distinct去重
        Integer[] arr = new Integer[]{3, 1, 3, 1, 2,4};
        Stream.of(arr).distinct().forEach(System.out::println);
        // 6、sorted排序
        Stream.of(arr).sorted().forEach(System.out::println);
        // 7、collect转换
        List<String> newList = list.stream().filter(str -> str.contains("+"))
                .collect(Collectors.toList());
        newList.stream().forEach(System.out::print);
    }
}

在没有Stream相关API之前，对于集合的操作和遍历都会产生大量的代码，通过Stream相关API集合的函数式编程和Lambda表达式的风格，简化集合很多操作。

文章标签：
Java
API
知了一笑
目录
相关文章
我不是游客20240119
|
5月前
|
并行计算 数据处理 UED
探索程序设计范式：面向对象编程与函数式编程之辩
在现代软件开发中，面向对象编程（OOP）和函数式编程（FP）是两种主流的程序设计范式。本文将对它们进行比较和分析，并探讨如何根据项目需求和个人喜好做出选择。无论是OOP的灵活性和可维护性，还是FP的简洁性和并发性，都有其独特的优势。
我不是游客20240119
40 6
A等天晴
|
12月前
|
分布式计算 前端开发 JavaScript
程范式解析：面向对象、函数式与声明式编程
程范式解析：面向对象、函数式与声明式编程
A等天晴
111 0
三分钟热度的鱼
|
3月前
|
自然语言处理 开发者
编程问题之函数式编程有什么优点
编程问题之函数式编程有什么优点
三分钟热度的鱼
38 0
游客moiomvrp3vyac2
|
5月前
|
大数据 开发者
探索编程范式：面向对象与函数式的抉择
在当今快速发展的软件开发领域，面向对象编程（OOP）和函数式编程（FP）是两种重要的编程范式。本文将深入比较这两种范式的特点、应用场景和优劣势，为读者提供选择时的参考，并探讨如何在实际项目中灵活运用它们。
游客moiomvrp3vyac2
84 2
mrq4nk6ni2neg
|
5月前
|
Java 程序员 数据处理
探索编程范式：面向对象编程与函数式编程的比较与取舍
本文将探讨面向对象编程（OOP）和函数式编程（FP）两种主流的编程范式，并比较它们在代码组织、可复用性、并发性和代码风格等方面的特点。通过深入了解它们的优势和不足，读者可以更好地选择适合自己项目需求的编程范式。
mrq4nk6ni2neg
232 1
众所周知
|
10月前
|
Java 开发者
Java面向对象编程的4个主要概念
Java面向对象编程的4个主要概念
众所周知
70 3
空白_d
面向对象概念
1. Coad和Yourdon给出了一个定义：面向对象=对象+类+继承+通信 2. 如果一个软件系统使用这样4个概念设计和实现，则我们认为这个软件系统是面向对象的 什么是对象(object)
空白_d
74 0
游客cflknejh75ig6
|
C++
C++面向对象的概念和特点
C++面向对象的概念和特点
游客cflknejh75ig6
46 0
阿里云社区
|
Java Scala 开发者
函数式编程几个重要概念|学习笔记
快速学习函数式编程几个重要概念。
阿里云社区
75 0
函数式编程几个重要概念|学习笔记
阿里云社区
|
算法 Java Scala
函数式编程基础介绍|学习笔记
快速学习函数式编程基础介绍。
阿里云社区
91 0
函数式编程基础介绍|学习笔记

热门文章

最新文章

  • 1
    阿里云服务器快速配置安全组放行端口方法
  • 2
    Linux下Apache服务的查看和启动
  • 3
    一起谈.NET技术，ASP.NET MVC2实现分页和右键菜单
  • 4
    线性回归
  • 5
    Win7中你所应该知道的强制计划关机操作
  • 6
    Windows Phone SDK update for Windows Phone 7.8
  • 7
    postgreSQl导数据
  • 8
    Android响应式编程开发RxAndroid（2）：简单例程的Android改造
  • 9
    SQL Server 事务嵌套
  • 10
    eXtremeComponents 的最后一页
  • 1
    Python Tricks:Python‘s Functions Are First-Class
    19
  • 2
    “The Zen of Python” Easter Egg
    19
  • 3
    Kali渗透测试：通过Web应用程序实现远程控制
    23
  • 4
    Kali渗透测试：Metasploit 6.0 中的Evasion模块 原创
    21
  • 5
    Python Tricks： A Shocking Truth About String Formatting（一）
    18
  • 6
    Python Tricks： A Shocking Truth About String Formatting（二）
    9
  • 7
    Kali渗透测试：使用工具Metasploit攻击操作系统（一）
    14
  • 8
    AI助理直击要害，从繁复中提炼精华——使用CDN加速访问OSS存储的图片
    40
  • 9
    Kali渗透测试：使用工具Metasploit攻击操作系统（二）
    11
  • 10
    Python tricksUnderscores, Dunders, and More续篇
    8

    • 相关课程

    更多
  • 5天玩转Java面向对象编程
  • Java面向对象编程
  • Python语言基础 - 函数、面向对象、异常处理
  • Java面向对象开发
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程

    • 相关电子书

    更多
  • 为什么要学函数式编程？
  • JavaScript面向对象的程序设计
  • 用RxSwift写易维护易读的愉悦代码

    • 相关实验场景

    更多
  • 面向对象-1：类的定义
  • 使用Java面向对象编写网络通信程序应用
    • 下一篇
    阿里云对象存储OSS怎么收费？包年包月和按量付费价格表