Java 函数式编程和 lambda 表达式

Java中的函数式编程:从Lambda表达式到Stream API 自Java 8引入函数式编程特性以来,开发者们获得了一种更加简洁、高效的编程方式。函数式编程是指通过将函数作为一等公民的形式来编写代码,减少不必要的样板代码,使代码更加简洁易读,尤其适合于处理集合类数据。Lambda表达式作为Java 8的核心更新之一,为我们提供了更具表现力的方式来定义行为,同时Stream API使得集合的处理变得更加直观和高效。本文深入探讨了Java中的Lambda表达式、方法引用、函数式接口,以及Stream API的强大功能,结合实际案例和详细的代码示例,帮助开发者充分掌握这些特性 阅读详情

点击上方“芋道源码”,选择“置顶公众号”

技术文章第一时间送达!

源码精品专栏

 

来源:http://t.cn/EhV6LNh

为什么要使用函数式编程

函数式编程更多时候是一种编程的思维方式,是种方法论。函数式与命令式编程的区别主要在于:函数式编程是告诉代码你要做什么,而命令式编程则是告诉代码要怎么做。说白了,函数式编程是基于某种语法或调用API去进行编程。例如,我们现在需要从一组数字中,找出最小的那个数字,若使用用命令式编程实现这个需求的话,那么所编写的代码如下:

public static void main(String[] args) {
    int[] nums = new int[]{1, 2, 3, 4, 5, 6, 7, 8};

    int min = Integer.MAX_VALUE;
    for (int num : nums) {
        if (num < min) {
            min = num;
        }
    }
    System.out.println(min);
}

而使用函数式编程进行实现的话,所编写的代码如下:

public static void main(String[] args) {
    int[] nums = new int[]{1, 2, 3, 4, 5, 6, 7, 8};

    int min = IntStream.of(nums).min().getAsInt();
    System.out.println(min);
}

从以上的两个例子中,可以看出,命令式编程需要自己去实现具体的逻辑细节。而函数式编程则是调用API完成需求的实现,将原本命令式的代码写成一系列嵌套的函数调用,在函数式编程下显得代码更简洁、易懂,这就是为什么要使用函数式编程的原因之一。所以才说函数式编程是告诉代码你要做什么,而命令式编程则是告诉代码要怎么做,是一种思维的转变。

说到函数式编程就不得不提一下lambda表达式,它是函数式编程的基础。在Java还不支持lambda表达式时,我们需要创建一个线程的话,需要编写如下代码:

public static void main(String[] args) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("running");
        }
    }).start();
}

而使用lambda表达式一句代码就能完成线程的创建,lambda强调了函数的输入输出,隐藏了过程的细节,并且可以接受函数当作输入(参数)和输出(返回值):

public static void main(String[] args) {
    new Thread(() -> System.out.println("running")).start();
}

注:箭头的左边是输入,右边则是输出

该lambda表达式的作用其实就是返回了Runnable接口的实现对象,这与我们调用某个方法获取实例对象类似,只不过是将实现代码直接写在了lambda表达式里。我们可以做个简单的对比:

public static void main(String[] args) {
    Runnable runnable1 = () -> System.out.println("running");
    Runnable runnable2 = RunnableFactory.getInstance();
}

JDK8接口新特性

1.函数接口,接口只能有一个需要实现的方法,可以使用@FunctionalInterface 注解进行声明。如下:

@FunctionalInterface
interface Interface1 {
    int doubleNum(int i);
}

使用lambda表达式获取该接口的实现实例的几种写法:

public static void main(String[] args) {
    // 最常见的写法
    Interface1 i1 = (i) -> i * 2;
    Interface1 i2 = i -> i * 2;

    // 可以指定参数类型
    Interface1 i3 = (int i) -> i * 2;

    // 若有多行代码可以这么写
    Interface1 i4 = (int i) -> {
        System.out.println(i);
        return i * 2;
    };
}

2.比较重要的一个接口特性是接口的默认方法,用于提供默认实现。默认方法和普通实现类的方法一样,可以使用this等关键字:

@FunctionalInterface
interface Interface1 {
    int doubleNum(int i);

    default int add(int x, int y) {
        return x + y;
    }
}

之所以说默认方法这个特性比较重要,是因为我们借助这个特性可以在以前所编写的一些接口上提供默认实现,并且不会影响任何的实现类以及既有的代码。例如我们最熟悉的List接口,在JDK1.2以来List接口就没有改动过任何代码,到了1.8之后才使用这个新特性增加了一些默认实现。这是因为如果没有默认方法的特性的话,修改接口代码带来的影响是巨大的,而有了默认方法后,增加默认实现可以不影响任何的代码。

3.当接口多重继承时,可能会发生默认方法覆盖的问题,这时可以去指定使用哪一个接口的默认方法实现,如下示例:

@FunctionalInterface
interface Interface1 {
    int doubleNum(int i);

    default int add(int x, int y) {
        return x + y;
    }
}

@FunctionalInterface
interface Interface2 {
    int doubleNum(int i);

    default int add(int x, int y) {
        return x + y;
    }
}

@FunctionalInterface
interface Interface3 extends Interface1, Interface2 {

    @Override
    default int add(int x, int y) {
        // 指定使用哪一个接口的默认方法实现
        return Interface1.super.add(x, y);
    }
}

函数接口

我们本小节来看看JDK8里自带了哪些重要的函数接口:

Java函数式编程和lambda表达式

可以看到上表中有好几个接口,而其中最常用的是Function接口,它能为我们省去定义一些不必要的函数接口,减少接口的数量。我们使用一个简单的例子演示一下 Function 接口的使用:

import java.text.DecimalFormat;
import java.util.function.Function;

class MyMoney {
    private final int money;

    public MyMoney(int money) {
        this.money = money;
    }

    public void printMoney(Function<Integer, String> moneyFormat) {
        System.out.println("我的存款: " + moneyFormat.apply(this.money));
    }
}

public class MoneyDemo {
    public static void main(String[] args) {
        MyMoney me = new MyMoney(99999999);

        Function<Integer, String> moneyFormat = i -> new DecimalFormat("#,###").format(i);
        // 函数接口支持链式操作,例如增加一个字符串
        me.printMoney(moneyFormat.andThen(s -> "人民币 " + s));
    }
}

运行以上例子,控制台输出如下:

我的存款: 人民币 99,999,999

若在这个例子中不使用Function接口的话,则需要自行定义一个函数接口,并且不支持链式操作,如下示例:

import java.text.DecimalFormat;

// 自定义一个函数接口
@FunctionalInterface
interface IMoneyFormat {
    String format(int i);
}

class MyMoney {
    private final int money;

    public MyMoney(int money) {
        this.money = money;
    }

    public void printMoney(IMoneyFormat moneyFormat) {
        System.out.println("我的存款: " + moneyFormat.format(this.money));
    }
}

public class MoneyDemo {
    public static void main(String[] args) {
        MyMoney me = new MyMoney(99999999);

        IMoneyFormat moneyFormat = i -> new DecimalFormat("#,###").format(i);
        me.printMoney(moneyFormat);
    }
}

然后我们再来看看Predicate接口和Consumer接口的使用,如下示例:

public static void main(String[] args) {
    // 断言函数接口
    Predicate<Integer> predicate = i -> i > 0;
    System.out.println(predicate.test(-9));

    // 消费函数接口
    Consumer<String> consumer = System.out::println;
    consumer.accept("这是输入的数据");
}

运行以上例子,控制台输出如下:

false
这是输入的数据

这些接口一般有对基本类型的封装,使用特定类型的接口就不需要去指定泛型了,如下示例:

public static void main(String[] args) {
    // 断言函数接口
    IntPredicate intPredicate = i -> i > 0;
    System.out.println(intPredicate.test(-9));

    // 消费函数接口
    IntConsumer intConsumer = (value) -> System.out.println("输入的数据是:" + value);
    intConsumer.accept(123);
}

运行以上代码,控制台输出如下:

false
输入的数据是:123

有了以上接口示例的铺垫,我们应该对函数接口的使用有了一个初步的了解,接下来我们演示剩下的函数接口使用方式:

public static void main(String[] args) {
    // 提供数据接口
    Supplier<Integer> supplier = () -> 10 + 1;
    System.out.println("提供的数据是:" + supplier.get());

    // 一元函数接口
    UnaryOperator<Integer> unaryOperator = i -> i * 2;
    System.out.println("计算结果为:" + unaryOperator.apply(10));

    // 二元函数接口
    BinaryOperator<Integer> binaryOperator = (a, b) -> a * b;
    System.out.println("计算结果为:" + binaryOperator.apply(10, 10));
}

运行以上代码,控制台输出如下:

提供的数据是:11
计算结果为:20
计算结果为:100

而BiFunction接口就是比Function接口多了一个输入而已,如下示例:

class MyMoney {
    private final int money;
    private final String name;

    public MyMoney(int money, String name) {
        this.money = money;
        this.name = name;
    }

    public void printMoney(BiFunction<Integer, String, String> moneyFormat) {
        System.out.println(moneyFormat.apply(this.money, this.name));
    }
}

public class MoneyDemo {
    public static void main(String[] args) {
        MyMoney me = new MyMoney(99999999, "小明");

        BiFunction<Integer, String, String> moneyFormat = (i, name) -> name + "的存款: " + new DecimalFormat("#,###").format(i);
        me.printMoney(moneyFormat);
    }
}

运行以上代码,控制台输出如下:

小明的存款: 99,999,999

方法引用

在学习了lambda表达式之后,我们通常会使用lambda表达式来创建匿名方法。但有的时候我们仅仅是需要调用一个已存在的方法。如下示例:

Arrays.sort(stringsArray, (s1, s2) -> s1.compareToIgnoreCase(s2));

在jdk8中,我们可以通过一个新特性来简写这段lambda表达式。如下示例:

Arrays.sort(stringsArray, String::compareToIgnoreCase);

这种特性就叫做方法引用(Method Reference)。方法引用的标准形式是:类名::方法名。(注意:只需要写方法名,不需要写括号)。

目前方法引用共有以下四种形式:

类型示例代码示例对应的Lambda表达式
引用静态方法ContainingClass::staticMethodNameString::valueOf(s) -> String.valueOf(s)
引用某个对象的实例方法containingObject::instanceMethodNamex::toString()() -> this.toString()
引用某个类型的任意对象的实例方法ContainingType::methodNameString::toString(s) -> s.toString
引用构造方法ClassName::newString::new() -> new String()

下面我们用一个简单的例子来演示一下方法引用的几种写法。首先定义一个实体类:

public class Dog {
    private String name = "二哈";
    private int food = 10;

    public Dog() {
    }

    public Dog(String name) {
        this.name = name;
    }

    public static void bark(Dog dog) {
        System.out.println(dog + "叫了");
    }

    public int eat(int num) {
        System.out.println("吃了" + num + "斤");
        this.food -= num;
        return this.food;
    }

    @Override
    public String toString() {
        return this.name;
    }
}

通过方法引用来调用该实体类中的方法,代码如下:

package org.zero01.example.demo;

import java.util.function.*;

/**
 * @ProjectName demo
 * @Author: zeroJun
 * @Date: 2018/9/21 13:09
 * @Description: 方法引用demo
 */
public class MethodRefrenceDemo {

    public static void main(String[] args) {
        // 方法引用,调用打印方法
        Consumer<String> consumer = System.out::println;
        consumer.accept("接收的数据");

        // 静态方法引用,通过类名即可调用
        Consumer<Dog> consumer2 = Dog::bark;
        consumer2.accept(new Dog());

        // 实例方法引用,通过对象实例进行引用
        Dog dog = new Dog();
        IntUnaryOperator function = dog::eat;
        System.out.println("还剩下" + function.applyAsInt(2) + "斤");

        // 另一种通过实例方法引用的方式,之所以可以这么干是因为JDK默认会把当前实例传入到非静态方法,参数名为this,参数位置为第一个,所以我们在非静态方法中才能访问this,那么就可以通过BiFunction传入实例对象进行实例方法的引用
        Dog dog2 = new Dog();
        BiFunction<Dog, Integer, Integer> biFunction = Dog::eat;
        System.out.println("还剩下" + biFunction.apply(dog2, 2) + "斤");

        // 无参构造函数的方法引用,类似于静态方法引用,只需要分析好输入输出即可
        Supplier<Dog> supplier = Dog::new;
        System.out.println("创建了新对象:" + supplier.get());

        // 有参构造函数的方法引用
        Function<String, Dog> function2 = Dog::new;
        System.out.println("创建了新对象:" + function2.apply("旺财"));
    }
}

类型推断

通过以上的例子,我们知道之所以能够使用Lambda表达式的依据是必须有相应的函数接口。这一点跟Java是强类型语言吻合,也就是说你并不能在代码的任何地方任性的写Lambda表达式。实际上Lambda的类型就是对应函数接口的类型。Lambda表达式另一个依据是类型推断机制,在上下文信息足够的情况下,编译器可以推断出参数表的类型,而不需要显式指名。

如果大家想学习以上路线内容,在此我向大家推荐一个架构学习交流群。交流学习群号874811168 里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

所以说 Lambda 表达式的类型是从 Lambda 的上下文推断出来的,上下文中 Lambda 表达式需要的类型称为目标类型,如下图所示:

Java函数式编程和lambda表达式

接下来我们使用一个简单的例子,演示一下 Lambda 表达式的几种类型推断,首先定义一个简单的函数接口:

@FunctionalInterface
interface IMath {
    int add(int x, int y);
}

示例代码如下:

public class TypeDemo {

    public static void main(String[] args) {
        // 1.通过变量类型定义
        IMath iMath = (x, y) -> x + y;

        // 2.数组构建的方式
        IMath[] iMaths = {(x, y) -> x + y};

        // 3.强转类型的方式
        Object object = (IMath) (x, y) -> x + y;

        // 4.通过方法返回值确定类型
        IMath result = createIMathObj();

        // 5.通过方法参数确定类型
        test((x, y) -> x + y);

    }

    public static IMath createIMathObj() {
        return (x, y) -> x + y;
    }

    public static void test(IMath iMath){
        return;
    }
}

变量引用

Lambda表达式类似于实现了指定接口的内部类或者说匿名类,所以在Lambda表达式中引用变量和我们在匿名类中引用变量的规则是一样的。如下示例:

public static void main(String[] args) {
    String str = "当前的系统时间戳是: ";
    Consumer<Long> consumer = s -> System.out.println(str + s);
    consumer.accept(System.currentTimeMillis());
}

值得一提的是,在JDK1.8之前我们一般会将匿名类里访问的外部变量设置为final,而在JDK1.8里默认会将这个匿名类里访问的外部变量给设置为final。例如我现在改变str变量的值,ide就会提示错误:

Java函数式编程和lambda表达式

至于为什么要将变量设置final,这是因为在Java里没有引用传递,变量都是值传递的。不将变量设置为final的话,如果外部变量的引用被改变了,那么最终得出来的结果就会是错误的。

下面用一组图片简单演示一下值传递与引用传递的区别。以列表为例,当只是值传递时,匿名类里对外部变量的引用是一个值对象:

Java函数式编程和lambda表达式

若此时list变量指向了另一个对象,那么匿名类里引用的还是之前那个值对象,所以我们才需要将其设置为final防止外部变量引用改变:

Java函数式编程和lambda表达式

而如果是引用传递的话,匿名类里对外部变量的引用就不是值对象了,而是指针指向这个外部变量:

Java函数式编程和lambda表达式

所以就算list变量指向了另一个对象,匿名类里的引用也会随着外部变量的引用改变而改变:

Java函数式编程和lambda表达式

级联表达式和柯里化

在函数式编程中,函数既可以接收也可以返回其他函数。函数不再像传统的面向对象编程中一样,只是一个对象的工厂或生成器,它也能够创建和返回另一个函数。返回函数的函数可以变成级联 lambda 表达式,特别值得注意的是代码非常简短。尽管此语法初看起来可能非常陌生,但它有自己的用途。

级联表达式就是多个lambda表达式的组合,这里涉及到一个高阶函数的概念,所谓高阶函数就是一个可以返回函数的函数,如下示例:

// 实现了 x + y 的级联表达式
Function<Integer, Function<Integer, Integer>> function1 = x -> y -> x + y;
System.out.println("计算结果为: " + function1.apply(2).apply(3));  // 计算结果为: 5

这里的 y -&gt; x + y 是作为一个函数返回给上一级表达式,所以第一级表达式的输出是 y -&gt; x + y这个函数,如果使用括号括起来可能会好理解一些:

x -> (y -> x + y)

级联表达式可以实现函数柯里化,简单来说柯里化就是把本来多个参数的函数转换为只有一个参数的函数,如下示例:

Function<Integer, Function<Integer, Function<Integer, Integer>>> function2 = x -> y -> z -> x + y + z;
System.out.println("计算结果为: " + function2.apply(1).apply(2).apply(3));  // 计算结果为: 6

如果大家想学习以上路线内容,在此我向大家推荐一个架构学习交流群。交流学习群号874811168 里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

函数柯里化的目的是将函数标准化,函数可灵活组合,方便统一处理等,例如我可以在循环里只需要调用同一个方法,而不需要调用另外的方法就能实现一个数组内元素的求和计算,代码如下:

public static void main(String[] args) {
    Function<Integer, Function<Integer, Function<Integer, Integer>>> f3 = x -> y -> z -> x + y + z;
    int[] nums = {1, 2, 3};
    for (int num : nums) {
        if (f3 instanceof Function) {
            Object obj = f3.apply(num);
            if (obj instanceof Function) {
                f3 = (Function) obj;
            } else {
                System.out.println("调用结束, 结果为: " + obj);  // 调用结束, 结果为: 6
            }
        }
    }
}

级联表达式和柯里化一般在实际开发中并不是很常见,所以对其概念稍有理解即可,这里只是简单带过,若对其感兴趣的可以查阅相关资料。



如果你对 Dubbo / Netty 等等源码与原理感兴趣,欢迎加入我的知识星球一起交流。长按下方二维码噢:


目前在知识星球更新了《Dubbo 源码解析》目录如下:

01. 调试环境搭建
02. 项目结构一览
03. 配置 Configuration
04. 核心流程一览

05. 拓展机制 SPI

06. 线程池

07. 服务暴露 Export

08. 服务引用 Refer

09. 注册中心 Registry

10. 动态编译 Compile

11. 动态代理 Proxy

12. 服务调用 Invoke

13. 调用特性 

14. 过滤器 Filter

15. NIO 服务器

16. P2P 服务器

17. HTTP 服务器

18. 序列化 Serialization

19. 集群容错 Cluster

20. 优雅停机

21. 日志适配

22. 状态检查

23. 监控中心 Monitor

24. 管理中心 Admin

25. 运维命令 QOS

26. 链路追踪 Tracing

... 一共 69+ 篇

目前在知识星球更新了《Netty 源码解析》目录如下:

01. 调试环境搭建
02. NIO 基础
03. Netty 简介
04. 启动 Bootstrap

05. 事件轮询 EventLoop

06. 通道管道 ChannelPipeline

07. 通道 Channel

08. 字节缓冲区 ByteBuf

09. 通道处理器 ChannelHandler

10. 编解码 Codec

11. 工具类 Util

... 一共 61+ 篇

目前在知识星球更新了《数据库实体设计》目录如下:

01. 商品模块
02. 交易模块
03. 营销模块
04. 公用模块

... 一共 17+ 篇

源码不易↓↓↓↓↓

点赞支持老艿艿↓↓

Java必知必会系列:函数式编程与Lambda表达式 作者:禅与计算机程序设计艺术 1.背景介绍 函数式编程(Functional Programming) 函数式编程(英语:Functional programming)是一种编程范型,它将电脑运算视作为数学计算,并且 阅读详情

相关推荐

Java 函数式编程与 Lambda 表达式

函数式编程是计算机科学的一个重要分支,它强调数据结构和函数的重要性,追求代码的可读性、可维护性和简洁性。函数式编程是使用函数式语言(如Haskell、Scala、F#等)编写的程序,它的核心思想是将程序拆分为一系列小函数,这些小函数实现了程序的业务逻辑。函数式编程的优点包括:提高代码的可读性和可维护性;提高程序的性能和可扩展性;降低程序的出错率。Lambda表达式是函数式编程中的一种重要技术,可以将一个表达式转换为一个函数,使得函数式编程更加灵活。

AI天才研究院 1万+

java之Lambda表达式与Stream流

Lambda,在我现在的技术来看,就是为了简化代码的它允许我们将函数当成参数传递给某个方法,或者把代码本身当作数据处理。很多JVM平台上的语言(Groovy、Scala等)从诞生之日就支持Lambda表达式,但是Java开发者没有选择,只能使用匿名内部类代替Lambda表达式。

梦想是很难很难的,所以先勇敢一点 1893

faster lio 回环 加入GTSAM优化的记录

对Faster lio 加入回环、gtsam优化,在室外建图遇到的问题和过程

Nico_jion的博客 2601

Java 函数式编程和 lambda 表达式详解

作者:DemonsImy.oschina.net/demons99/blog/2223079为什么要使用函数式编程函数式编程更多时候是一种编程的思维方式,是种方法论。函数式与命令式编程的...

Java笔记虾 577

开源分享:苹果群控手机源代码解析与实战

本文介绍了苹果设备群控的基本原理和实现方法,重点解析了基于Python+Appium的群控系统构建。主要内容包括:1)设备连接管理技术(USB/Wi-Fi);2)自动化控制方式(WDA/AppleScript/Appium);3)实战演示了通过Python脚本实现多设备同时控制,涵盖环境配置、代码解析和功能说明;4)提出了多线程、图像识别等优化方向。文章为开发者提供了快速上手的群控方案,适用于自动化测试、批量管理等场景,并推荐了相关开源项目参考。

2403_88540309的博客 1348

小论文/大论文必备| YOLO26热力图可视化,支持8种常用热力图方法:GradCAM,GradCAMPlusPlus,XGradCAM,EigenCAM,HiResCAM等,助力小论文和大论文加分

本文介绍了如何为YOLO26模型添加热力图可视化功能,包括完整代码和使用教程。热力图能增强模型的可解释性,适用于论文中的实验对比和结果展示。文章提供了详细的代码实现,包含图像处理、热力图生成和结果可视化等功能,并指导用户如何创建Python文件、粘贴代码以及调整参数生成最佳热力图。通过设置不同层号,用户可以灵活控制热力图效果,最终结果将保存在指定文件夹中。

Ai缝合怪、助力小伙伴高效发论文 496

深入理解Lambda表达式-函数式编程-Stream流(最全学习笔记)

Lambad表达式:Lambda是JDK8中一个语法糖。他可以对某些罩名内部类的写法进行简化。它是函数式编程思想的一个重要体现。让我们不用关注是什么对象。而是更关注我们对数据进行了什么操作。

Good good study,day day up 625

基于树莓派4B与NCNN的YOLOv8高效部署实战:无GPU环境下的C++加速优化全流程指南**

本文详细介绍了在树莓派4B上基于NCNN框架部署YOLOv8目标检测模型的全流程。内容包括:从PyTorch模型导出NCNN格式文件、树莓派环境配置(OpenCV和NCNN编译)、C++实现代码解析(含模型加载、推理及后处理),以及实际部署测试结果。在树莓派4B上达到约2FPS,并提供INT8量化、多线程等优化建议。该方案为无GPU设备提供了轻量化目标检测的实用部署方案,适合边缘计算场景。

FJN110的博客 919

Java8函数式编程(Lambda表达式)

首先使用 Stream 的 forEach 方法替换掉 for 循环,但还是暂时保留原来循环体中的代码,这是在重构时非常方便的一个技巧。有时,reduce 操作不存在有意义的初始值,这样做就是有意义的,此时,reduce 方法返回一个 Optional 对象。在要对流求值时,不能同时处于两种模式,要么是并行的,要么是串行的。然后使用 for 循环遍历所有专辑,每次循环中再使用一个 for 循环遍历每张专辑上的每首曲目,检查其长度是否大于 60 秒,如果是,则将该曲目名称加入 Set 对象。

琅琊之榜 1020

电气:蒙特卡洛1000个风光场景并通过削减法|聚类法得到几个典型场景(matlab\python实现)

    个人电气目录传送门:学好电气全靠它,个人电气博文目录(持续更新中…)     本文内容包括22页(代码和一些自己对风光的观点) 提示:专栏解锁后,可以查看该专栏所有文章,划算。 文章目录一、理论依据1.风电DG出力概率模型1.2光伏DG出力概率模型1.3对风光的认识二、蒙特卡洛模拟1000个风光场景、并通过削减法得到5个典型风电场景 (Matlab 版程序)三、蒙特卡洛模拟1000个风光场景、并通过聚类法得到5个典型

总裁余(余登武)博客 7682

基于C#通过PLCSIM ADV仿真软件实现与西门子1500PLC的S7通信方法演示

基于C#通过PLCSIM ADV仿真软件实现与西门子1500PLC的S7通信方法演示

Robot_PLC_HMI_Automation 3164

Java函数式编程和Lambda表达式

文章目录什么是函数式编程Lambda表达式@FunctionalInterface函数式接口Lambda表达式的格式方法引用 什么是函数式编程 相信大家都使用过面向对象的编程语言,面向对象编程是对数据进 行抽象,而函数式编程是对行为进行抽象。函数式编程让程序员能够写出更加容易阅读的代码。那什么时候函数式编程呢? 函数式编程是一种编程的方法论,主要是将行为编写成一个个的函数。 什么是函数? 函数就是...

程序那些事 1万+

PCL 直通滤波器【2026最新版】

PCL直通滤波器函数详解以及用于多字段滤波、强度滤波、获取某一时间范围内的点等高阶用法案例分享。博客长期更新,本文最近一次更新时间为:2026年3月11日。

点云侠的博客 40万+

浅谈Java lambda表达式和函数式编程

浅谈Java lambda表达式和函数式编程什么是Java lambda表达式?函数式编程是啥?lambda表达式是函数式编程的一种吗?

菜菜bu菜的博客 2330

20、基于图神经网络的脱氢焓预测方法研究

本文研究了基于图神经网络(GNN)的液态有机氢载体(LOHC)材料脱氢焓预测方法。通过分析现有GNN方法的局限性,提出了一种新的聚合自节点表示(AWS)方法,并结合丰富的原子特征和集成学习策略,显著提高了预测性能。实验结果表明,AWS在脱氢焓预测和多个基准化学性质预测任务中均优于现有GNN方法。此外,基于分子结构的集成方法进一步提升了模型的鲁棒性和准确性。研究展示了该方法在筛选LOHC材料中的潜力,并为未来预测更多化学性质奠定了基础。

pp12345的博客 104

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

Java函数式编程+Lambda表达式

Java8新引入函数式编程方式,大大的提高了编码效率。从面向对象编程视角来看,程序中使用的变量,其实只是一个值的容器,这个容器中,可以放置不同的值。从函数式编程视角,变量其实只是值的一个“别名”,值本身是不能改的。采用函数式编程思想设计类,强调“类”所封装的数据,应该只被初始化一次,之后就不再更改。JDK中的String类型,就是用“函数式编程”风格设计出来的一个例子。Java 8引入了Lambda表达式特性,提供了Stream API。

sjb2274540432的博客 1481

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Java8 Lambda表达式 和 函数式编程 原理详解

前言 1、前言   Java8既JDK1.8。Lambda表达式是Java8的新特性,除此之外Java8还提供了其他新特性,比如:函数式编程、方法引用、Stream、Optional类、默认方法、新的日期类型、Base64、Nashorn, JavaScript 引擎。   本篇详细介绍Lambda表达式,其他的后续慢慢介绍。   它是一个语法糖,糖是甜的,但是对于初学者并不是,当你熟悉之后,你会发现,它是真的香。   Lambda表达式的初衷是,进一步简化匿名类的语法(不过实现上,Lambda表达

Curry4ever 2758

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Java函数式编程与Lambda表达式

C++,Java,C#,Python等各个编程语言早已经支持lambda表达式了,作为即将从业的大学生,现在学习Java的函数式编程应该为时不晚。 FunctionalInterface函数式接口 四个最基本的函数式接口 基本数据类型的函数式接口 1double类型的函数式接口 2int类型的函数式接口 3long类型的函数式接口 4boolean类型的函数式接口 一元函数式接口 用于类...

优快云文章已停止维护,后续文章会在 https://blog.hufeifei.cn 持续更新 7084

Java8函数式编程和lambda表达式

文章目录函数式编程JDK8接口新特性函数接口方法引用 函数式编程 函数式编程更多时候是一种编程的思维方式,是一种方法论。函数式与命令式编程区别主要在于:函数式编程是告诉代码你要做什么,而命令式编程则是告诉代码要怎么做。简单说,函数式编程是基于某种语法或调用API去进行编程。 例如,从整型数组中找出最小的那个数字,采用命令式编程实现如下: public static void main(String...

FEEL的博客 3242

深度探讨Java的Lambda表达式与函数式编程范式

通过深度探讨Lambda表达式及其相关的函数式编程特性,我们不仅仅学会了语法和使用方法,更深入理解了函数式编程的思想。Lambda表达式使得Java更具表达力,代码更为简洁,为开发者提供了更多的选择和灵活性。在实际项目中,合理运用Lambda表达式和函数式编程思想,能够使代码更具可读性、可维护性,提高开发效率。愿读者通过本篇博客,对Java的Lambda表达式有更为深刻的理解。屏幕前的你,祝你今天能够拥有好超级运气!

喔的嘛呀的博客 1330

Java 函数式编程入门:Lambda 表达式

本文围绕 Java 中的 Lambda 表达式展开,介绍其作为 JDK8 引入的函数式编程语法的核心价值。首先分析匿名内部类在实现接口时的冗余问题,引出 Lambda 表达式简化代码的作用。阐述其基本格式 “(参数列表)->{方法体}” 及函数式接口这一使用前提,详解参数类型省略、单参数括号省略、单行方法体简化等规则。通过游泳接口实现和字符串数组排序案例,展示从匿名内部类到 Lambda 表达式的简化过程,说明其聚焦逻辑、提升可读性的优势,为理解函数式编程及后续学习打下基础。

Shabbt的博客 1163

在Java中如何使用Lambda表达式进行函数式编程

在这个示例中,我们使用了Lambda表达式和Stream API来将整数列表中的每个元素映射到其平方,并使用。Java 8引入了Stream API,它允许你以函数式的方式处理集合。这些技术都是Java中进行函数式编程的重要组成部分。Lambda表达式允许你简洁地实现函数式接口。函数式接口是一个只有一个抽象方法的接口。来实现它,这个表达式表示一个将输入值平方的函数。方法可以将多个函数组合在一起,创建更复杂的函数。类型的变量,你可以使用Lambda表达式。包中定义了许多常用的函数式接口,如。

m0_60521228的博客 539

java 8函数式编程与Lambda表达式

这篇文章不是我原创的,见其简 单易懂,就拿过来了。原文详见http://www.infoq.com/cn/articles/Concise-Java?utm_source=infoq&utm_medium=related_content_link&utm_campaign=relatedContent_articles_clk Java的设计目标包括面向对象、易于上手(在当时,这意味着使用C

cktmyh的专栏 1120

Java 的函数式编程与 Lambda 表达式(21/30)

在传统的命令式编程中,程序通过一系列的命令来改变程序的状态,而在函数式编程中,程序由一个个函数组合而成,通过函数的调用链式处理数据。无副作用:函数的执行不会影响到外部状态。不可变性:数据尽量保持不可变。高阶函数:函数可以作为参数传递给其他函数,或者作为返回值。Java 的函数式编程特性主要体现在 Lambda 表达式和函数式接口的引入上。除了内置的函数式接口,开发者还可以根据需求自定义函数式接口。示例:自定义函数式接口。

weidl001的博客 1012
上一篇: 排序算法总结(多图)
下一篇: 端游、手游服务端常用的架构是什么样的?
公众号-芋道源码
博客等级 码龄10年 1637粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值