函数式编程

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量270 收藏
点赞数 2
文章标签： java 函数式编程 lambda 函数式接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41986648/article/details/104802063
版权
函数式编程的理解

        函数式编程的【函数】是指数学上的函数。
        数学上的函数概念含有三个要素：定义域A、值域C和对应法则f。
        其中核心是对应法则f，它是函数关系的本质特征。这也是函数式编程的特征
        这里引用知乎上的一个解释：什么是函数式编程?.

1. 函数式接口

1.1概述

        如果说一个接口内有且只有一个方法，而且该方法是一个缺省属性为public abstract方法，该接口可以称之为是一个函数式接口。
包括：
        自定义函数式接口
        系统中提供的函数式接口        如：    Comparator<T>    Runnable
        可以直接利用JDK1.8的新特征，使用Lambda表达式
        Lambda表达式相对于匿名内部类：
                1.简化了代码结构
                2.节约了内存资源
                3.让程序员更关注最终目的是做什么事，而不是为了达到目的所完成的操作。

1.2@FunctionalInterface 使用

        类似于@Override，开启代码重写格式严格检查
格式：

/**
 * 使用@FunctionalInterface检查函数式接口格式问题
 * 要求当前接口中有且只有一个缺省属性为public abstract的方法
 *
 * @author Anonymous 2020/3/11 9:55
 */
@FunctionalInterface
public interface FunctionalType {
    void test();
}

1.3使用【自定义的函数式接口】作为【方法的参数】

作用：
        代码中使用函数式接口
                1. 让程序的目的性更强
                2. 提供复用，普适性的价值
                3. 节约资源
代码演示：

package com.a_functional;

/**
 * 1.自定义函数式接口作为方法的参数演示
 *
 * @author Anonymous 2020/3/11 9:55
 */
public class Demo1 {
    public static void main(String[] args) {
        /*
        使用匿名内部类来完成函数式接口的使用，但是这种方式有悖于函数式接口的目的
        Low

        useFunctionalInterface(new FunctionalType() {
            @Override
            public void test() {
                System.out.println("匿名内部类的匿名对象直接作为方法的参数。");
            }
        });
        int(*) (char **, int *)
            C语言中的函数指针
            如果是C语言中，这需要的参数是方法名
        */
       useFunctionalInterface(() -> System.out.println("函数式接口 lambda表达式实现完成方法，实现目的"));
    }

    /**
     * 2.使用一个函数式接口作为方法的参数
     *
     * @param ft 函数式接口的实现类对象，或者说直接操作本质，直接传入Lambda表达式
     */
    public static void useFunctionalInterface(FunctionalType ft) {
        ft.test();
    }
}

2. 函数式编程思想

2.1Lambda延迟执行

2.1.1 日志记录

        日志是否保存会存在等级限制，因此这里演示一个根据不同的等级来记录log日志

package com.b_lambda;

enum Level {
    /**
     * 枚举测试
     */
    HIGH, MIDDLE, LOWER
}

/**
 * 日志等级记录操作
 *
 * @author Anonymous 2020/3/11 10:17
 */
public class Demo1 {
    public static void main(String[] args) {
        /*
        这里存问题:
            "异常位置XXX，" + "异常问题XXX，" + "异常时间XXX" 字符叠加过程，会产生
            5个字符串
            这5个字符串如果Level.HIGH等级是有用的，但是除此之外是没有任何作用的。
            MIDDLE，LOWER是没有必要进行字符串累加，存在资源浪费问题。

            字符串的累加过程，需要经过Level判断之后才可以执行，避免没有必要的性能浪
            费。

            这里就可以使用Lambda表达式执行的延迟性，在没有满足level情况下，不去做字
            符串累加过程。
            这里需要【函数式接口】
         */
        log(Level.MIDDLE, "异常位置XXX，" + "异常问题XXX，" + "异常时间XXX");
    }

    /**
     * 判断等级是否需要记录当前日志信息
     *
     * @param level  等级，枚举类型
     * @param logMsg 需要记录的日志信息
     */
    public static void log(Level level, String logMsg) {
        // 判断是否满足枚举类型 Level.HIGH要求
        if (Level.HIGH == level) {
            System.err.println(logMsg);
        }
    }
}
2.1.2使用函数式接口提供日志信息功能

        这里需要一个函数式接口，返回值类型是String类型，其他的无所谓。

package com.b_lambda;

/**
 * 提供返回值为String类型方法的函数式接口
 *
 * @author Anonymous 2020/3/11 10:52
 */
@FunctionalInterface
public interface LogMessage {
    /**
     * 函数式接口中方法内容，该方法的返回值是String类型
     *
     * @return String类型返回值
     */
    String returnLogMessage();
}

package com.b_lambda;

/**
 * 使用函数式接口完成Log日志记录问题
 *
 * @author Anonymous 2020/3/11 10:53
 */
public class Demo2 {
    public static void main(String[] args) {
        String msg1 = "异常位置XXX，";
        String msg2 = "异常问题XXX，";
        String msg3 = "异常时间XXX";

        log(Level.LOWER, () -> {
            System.out.println("Lambda表达式执行!!!");
            return msg1 + msg2 + msg3;
        });
    }

    /**
     * 根据日志等级Level来确定是否需要记录日志
     *
     * @param level Level枚举类型，有三个数据 HIGH MIDDLE LOWER
     * @param lm LogMessage函数式接口做方法的参数
     */
    public static void log(Level level, LogMessage lm) {
        /*
        发现当Level等级为HIGH，执行对应的lm.returnLogMessage();
        Level等级不是HIGH不执行对应的方法。

        Lambda执行延迟问题不是Lambda效率执行慢，而是在执行之前多了一个判断
        是在判断之后才可以执行对应的代码。
            不执行代码字符串不会产生拼接导致的资源浪费问题，从而提高效率。
         */
        if (Level.HIGH == level) {
            // 通过函数式接口获取调用对应的returnLogMessage()方法
            System.err.println(lm.returnLogMessage());
        }
    }

    public static void testEnum(int level) {
        if (Level.HIGH.getStatus() == level) {

        }
    }
}

2.2Lambda作为方法参数和返回值

        参数演示：
                Runable接口

package comb_lambda;

/**
 * Runnable接口函数式接口使用，作为方法的参数
 *
 * @author Anonymous 2020/3/11 11:18
 */
public class Demo3 {
    public static void main(String[] args) {
        // 匿名内部类来完成对应当前Runnable接口实现类对象使用，作为Thread构造方法参数
        // low
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程代码");
            }
        }).start();

        // Lambda表达式直接作为方法的参数
        Thread thread = new Thread(() -> {

            System.out.println("线程执行需要时间");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程执行");
        }
        , "线程");

        thread.start();
    }
}

Java中提供的比较接口Comparator<T>
        利用一些返回值作为方法中操作的条件

public interface Comparator<T> {
	int compare(T o1, T o2);
}

package com.b_lambda;

import java.util.Arrays;
import java.util.Comparator;

/**
 * Lambda表示完成函数式接口，利用返回值作为其他操作所需的数据
 *
 * @author Anonymous 2020/3/11 11:25
 */
public class Demo4 {
    public static void main(String[] args) {
        /*
        字符串排序默认是一个字典顺序
         */
        String[] arr = {"eeeeeeee", "2a","dddd",  "1bb", "ccccccc", "3fffff"};

        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

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

        // 利用一个函数式接口完成的方法，利用方法的返回值作为当前sort方法运行
        // 所需参数，该参数用于比较规则约束
        Arrays.sort(arr, stringComparator());
        System.out.println(Arrays.toString(arr));

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

        Arrays.sort(arr, (a, b) -> a.length() - b.length());

        Arrays.sort(arr, Comparator.comparingInt(String::length));
        /*
        Comparator.comparingInt(String::length)

        Comparator:接口
        comparingInt:按照Int类型方式比较判断
        String:表示比较的类型是String，比较什么类型用什么类型
        length:按照String类型的哪一种方式比较
        */
        System.out.println(Arrays.toString(arr));


    }

    /**
     * 按照字符串长度排序，返回值类型是一个Comparator<String>接口
     * 这里需要完成Comparator接口中的compare方法
     *
     * @return 已经完成方法体的Comparator接口，并且数据类型是String类型
     */
    public static Comparator<String> stringComparator() {
        /*
        public interface Comparator<T> {
            int compare(T o1, T o2);
        }
         */
        return (a, b) -> b.length() - a.length();
    }
}

3.Java中提供的常用函数式接口

3.1JDK常用函数式接口概述

java.util.function包名，提供了很多函数式接口
常用的有：
        Supplier<T> 生产者，返回一个指定类型的数据
        Consumer<T> 消费者，消耗一个指定类型的数据
        Predicate<T> 判断条件，过滤使用
        Function<T,R>类型转换，根据指定的类型T，转换成对应的类型R

3.2 Supplier<T>生产者，返回一个指定的数据类型

**java,util.function.Supplier<T>
        有且只有一个方法
                T get();
                不需要参数，返回指定T类型数据

package com.c_supplier;

import com.b_lambda.Level;

import java.util.function.Supplier;

/**
 * Supplier函数式接口演示
 *
 * @author Anonymous 2020/3/11 14:44
 */
public class Demo1 {
    public static void main(String[] args) {
        String msg1 = "异常位置XXX，";
        String msg2 = "异常问题XXX，";
        String msg3 = "异常时间XXX";

        /*
        这里需要的是一个函数式接口，直接传入一个lambda表达式
         */
        log(Level.HIGH, () -> {
            System.out.println("Lambda表达式执行!!!");
            return msg1 + msg2 + msg3;
        });

        /*
        Lambda表达式优化
         */
        log(Level.HIGH, () -> msg1 + msg2 + msg3);
    }

    /**
     * 根据日志等级Level来确定是否需要记录日志
     *
     * @param level Level枚举类型，有三个数据 HIGH MIDDLE LOWER
     * @param supplier Supplier函数式接口，利用T get() 完成提供数据操作
     */
    public static void log(Level level, Supplier<String> supplier) {
        /*
        Supplier函数式接口利用get方法，提供对应的返回指定String类型数据的操作
         */
        if (Level.HIGH == level) {
            // 通过函数式接口获取调用对应的returnLogMessage()方法
            System.err.println(supplier.get());
        }
    }
}

3.3Consumer 消费者，处理数据

Consumer<T>
        操作使用的方法是
                void accept(T t);
                根据接口指定的数据类型接受对应数据，进行处理和消费，对外没有任何的返回。【sout不算返回】

package com.d_consumer;

import java.util.function.Consumer;

/**
 * 使用Consumer处理数据
 *
 * @author Anonymous 2020/3/11 15:24
 */
public class Demo1 {
    public static void main(String[] args) {
        // 该方法需要的参数是一个String类型，同时使用Consumer接口处理数据
        // 因为Consumer接口是一个函数式接口，可以使用Lambda表达式
        testConsumer("宫保鸡丁,番茄牛腩,酱牛肉,黄焖鸡米饭", (str) -> {
            String[] split = str.split(",");
            for (String s : split) {
                System.out.println(s);
            }
        });
    }

    /**
     * 给予当前方法一个String类型，通过Consumer函数式接口中的accept方法完成对应
     * 字符串处理
     *
     * @param str String类型字符串
     * @param consumer Consumer处理数据的函数式接口
     */
    public static void testConsumer(String str, Consumer<String> consumer) {
        consumer.accept(str);
    }
}

package com.d_consumer;

import java.util.function.Consumer;

/**
 * Consumer接口andThen使用
 * 需要两个Consumer接口，两个Consumer接口进行组合处理，对数据进行消费
 *
 * andThen(Consumer<T> con)
 *      调用格式
 *          con1.andThen(con2).accept(T t);
 *          等价于一下操作
 *          con1.accept(t);
 *          con2.accept(t);
 *
 * @author Anonymous 2020/3/11 15:57
 */
public class Demo2 {
    public static void main(String[] args) {
        /*
        该方法需要两个Consumer函数式接口，这里可以使用两个Lambda表达式操作
         */
        testAndThen("郑州加油!!!中国加油!!!",
                (str) -> System.out.println(str)
                ,
                (str) -> System.err.println(str)
                );
    }

    /**
     * 使用两个Consumer消费者方式处理str数据，首先是con1处理，再来con2处理
     *
     * @param str  需要处理的String类型数据
     * @param con1 Consumer<String> 处理String类型函数式接口
     * @param con2 Consumer<String> 处理String类型函数式接口
     */
    public static void testAndThen(String str, Consumer<String> con1, Consumer<String> con2) {
        /*
        con1.accept(str);
        con2.accept(str);

        允许组合拳
        con1.andThen(con2).andThen(con1).andThen(con2).andThen(con1).andThen(con2).accept(str);
        */
        con1.andThen(con2).accept(str);
    }
}

3.4 Predicate 判断数据是否合适，返回true/false

Predicate一般用于调节判断，过滤数据的方法
        函数式接口中指定的方法
        boolean test(T t);
                处理T类型数据，返回boolean true / false

package com.e_predicate;

import java.util.function.Predicate;

/**
 * 演示Predicate<T>基本使用
 *      boolean test(T t)
 *
 * @author Anonymous 2020/3/11 16:11
 */
public class Demo1 {
    public static void main(String[] args) {

        // Predicate函数式接口，使用Lambda表达式作为方法的参数
        boolean b = testPredicate("郑州奥力给!!!中国奥力给!!!",
                (str) -> {
                    return str.contains("加油");
                });

        System.out.println("ret : " + b);

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

        /*
        优化Lambda表达式，
            因为是一个参数，小括号可以省略
            就一行代码，大括号可以省略
            return也可以省略
         */
        testPredicate("郑州奥力给!!!中国奥力给!!!", str -> str.contains("加油"));
    }

    /**
     * 使用Predicate函数式接口利用boolean test(T t)对于当前数据进行判断操作，
     * 返回boolean类型数据
     *
     * @param str 需要进行判断数据的String类型字符串
     * @param pre 处理使用Predicate函数式接口
     * @return 判断接口是否满足要求，满足返回true，不满足返回false
     */
    public static boolean testPredicate(String str, Predicate<String> pre) {
        return pre.test(str);
    }
}

3.5 Function类型转换

        使用R apply(T t)
                转换指定类型T到R

package com.f_function;

import com.c_supplier.Person;

import java.util.function.Function;

/**
 * Function<T, R> 函数式接口
 *      R apply(T)
 *
 * @author Anonymous 2020/3/11 16:50
 */
public class Demo1 {
    public static void main(String[] args) {
        // Integer类型转换成一个String
        String change = change(10, i -> i + "");
        System.out.println(change);

        // 利用函数式接口处理一个String类型，转换成对应的Person类型
        Person person1 = change("1,骚磊,16", str -> {
            String[] split = str.split(",");
            Person person = new Person();

            person.setId(Integer.parseInt(split[0]));
            person.setName(split[1]);
            person.setAge(Integer.parseInt(split[2]));

            return person;
        });

        System.out.println(person1);
    }

    /**
     * 转换格式的方法，要求数据从Integer类型转换到指定的String类型
     *
     * @param i 需要转换的Integer类型
     * @param fun 转换使用的Function函数式接口
     * @return 返回值的是String类型
     */
    public static String change(Integer i, Function<Integer, String> fun) {
        return fun.apply(i);
    }

    public static Person change(String str, Function<String, Person> fun) {
        return fun.apply(str);
    }
}
YJ~
关注
python函数式编程
qq_59392324的博客
03-25 4744
大家好，这里还还还是长弓 今天我们来讲讲python中的函数式编程 函数式编程 有些同学疑惑了，我们已经学了函数，为什么还要学这个函数式编程呢？ 两者的区别是什么呢？ 函数是一个语法，函数式编程是一种编程的思路 是将本是CPU加减乘除的过程封装成一个个函数，调用函数的过程，更整体，更人性 函数式编程允许传入一个函数作为函数...
黑马程序员Java函数式编程全套视频教程，Lambda表达式、Stream流、函数式编程一套全通关1
05-16
Java函数式编程是一种高效、简洁的编程范式，它在Java 8中得到了全面支持，大大改变了Java开发人员编写代码的方式。本套黑马程序员的Java函数式编程视频教程涵盖了Lambda表达式、Stream流以及函数式编程的核心概念，...
Java 函数式编程
热门推荐
hua226的博客
04-25 4万+
Java 函数式编程 一、Lambda表达式 1.1 函数式编程思想概述 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作” 面向对象思想强调“必须通过对象的形式来做事情” 函数式思想强调则金量忽略面向对象的复杂语句：“强调做什么，而不是以什么形式去做” 而我们要学习的Lambda表达式就是函数式思想的体现 1.2 体验Lambda表达式 需求：启动一个线程，在控制台输出一句话：多线程程序启动了 方式1： 定义一个类MyRunnable接口，重写run方法 创建MyRunnable类
java函数式编程
2401_83447580的博客
07-23 1196
函数式接口是只包含一个抽象方法的接口（不包括Object类中的方法）。这样的接口可以被隐式地转换为Lambda表达式。Stream API 提供了一种高效且易于使用的方式来处理集合（Collection）和数组。Stream操作分为中间操作（Intermediate Operations）和终端操作（Terminal Operations）。方法引用是Lambda表达式的一种简洁写法，它允许你直接引用已存在的方法或构造器。
前端开发之函数式编程
薛定谔的猫-前端领域
04-28 1278
通用的函数式编程语言，是Haskell，被函数式原教旨主义者认为是纯函数式语言。函数式编程的思想也不断影响着传统编程语言，比如Java 8开始支持lambda表达式，而函数式编程的大厦最初就是基于lambda计算构建起来的。函数式编程对于前端来说是必选项，后端则不必。 React框架的组件从很早开始就是不仅支持类式组件，也支持函数式的组件。而后React Hooks的出现，使得函数式编程思想越来越变得不可或缺。 无副作用 这是函数式编程的精髓所在。 无副作用的函数应该符合下面的特点：
Python函数式编程
2302_76708905的博客
06-17 1381
介绍了函数式编程知识：函数式编程基本、函数式编程的三大基础函数和装饰器等内容
Java函数式编程
qq_49487356的博客
05-06 8121
函数式接口：有且仅有一个抽象方法的接口Java 中的函数式编程体现就是 Lambda 表达式，所以函数式接口就是可以适用于 Lambda 使用的接口只有确保接口中有且仅有一个抽象方法，Java 中的 Lambda 才能顺利地进行推导如何检测一个接口是不是函数式接口呢？放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败。
scala函数式编程
weixin_53898747的博客
04-03 1391
目录不同范式对比：1.面向对象编程2.函数式编程2.1函数基本语法2.2函数和方法的区别核心概念： 2.3函数定义 2.4函数参数2.5 函数至简原则2.6.高阶函数 三.偏函数四.柯里化函数五.递归函数递归函数注意点： 六.控制抽象1.值调用，把计算后的值传递过去， 2.名调用，把代码传递过去，七.惰性加载面向对象和面向过程都是命令式编程，但是函数式编程不关心具体运行过程，而是关心数据之间的映射。纯粹的函数式编程语言中没有变量，所有量都是常量，计算过程就是不停的表达式求值的过程，每一段程序都有返回值。不关
Java基础函数式编程
孤夜的博客
09-06 2552
本篇博文主要总结四个知识点,函数式接口,Java的函数式编程,方法引用,和Stream API。
函数式编程思想概论
灵动的艺术的博客
06-26 4887
函数式编程思想概论前言函数λ 演算λ项绑定变量和自由变量约简α 变换β 约简η 变换纯函数、副作用和引用透明性函数式编程与并发编程总结 原文地址 前言 在讨论函数式编程（Functional Programming）的具体内容之前，我们首先看一下函数式编程的含义。在维基百科上，函数式编程的定义如下：“函数式编程是一种编程范式。它把计算当成是数学函数的求值，从而避免改变状态和使用可变数据。它是一种声...
函数式编程思维.pdf_函数式编程_函数式编程思维_
10-03
函数式编程是一种编程范式，它强调将计算视为数学函数的评估，并避免可变状态和副作用。这种编程风格鼓励使用纯函数，即那些输入相同输出始终一致且不改变外部状态的函数。函数式编程有着深厚的理论基础，源于&lambda;演算...
Python函数式编程（第2版）1
08-03
《Python函数式编程（第2版）》是一本面向Python开发者深入探讨函数式编程的书籍。函数式编程是一种编程范式，它强调使用函数作为基本的构建块，以减少副作用和状态变化，从而提高代码的可读性和可维护性。Python虽...
Python函数式编程实例详解
12-23
本文实例讲述了Python函数式编程。分享给大家供大家参考，具体如下： 函数式编程就是一种抽象程度很高的编程范式，从计算机硬件->汇编语言->C语言->Python抽象程度越高、越贴近于计算，但执行效率也越低。纯粹的函数...
java8函数式编程（csdn）————程序.pdf
12-01
Java 8 函数式编程 Java 8 函数式编程是指在 Java 8 中引入的一种新的编程范式，它强加了额外的约束，即所有数据必须是不可变的，设置一次，永不改变。函数式编程将值传递给函数，该函数然后生成新值但从不修改...
Java-网络
最新发布
2301_81543552的博客
09-14 717
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
自动生成不重复的订单id
ClaireCheney的博客
09-13 305
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1164
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 755
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
函数式编程入门解析
"通俗讲解函数式编程" 函数式编程是一种编程范式，与常见的命令式编程（如C++、Java）不同，它强调程序执行的本质是数学函数的计算，而不是指令的顺序执行。在这个编程风格中，函数被视为第一类公民，意味着它们...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值