函数式编程 - 技术栈

函数式编程（lambda）

哈喽，大家好，又到了技术成长的一天。今天向大家分享一个编程利器-函数式编程之lambda。Lambda函数式编程在前端后端编程中使用非常广泛，我们现在就一起去深入了解一下它是什么，怎么用。

什么是函数式编程

函数式编程是种编程方式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。

函数式编程的优势与特点

首先我们了解函数式编程的优势

代码简洁，开发快速；
接近自然语言，易于理解；
更方便的代码管理；
易于"并发编程"；
代码的热升级。

其中，代码简洁，开发快速是指函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。
其次，我们看看他的特点

闭包和高阶函数
惰性计算
递归
函数是"第一等公民"
只用"表达式"，不用"语句"
没有"副作用"
不修改状态
引用透明性

Lambda函数式编程

什么是lambda表达式

Lambda是计算机编程语言，Lambda 表达式"是一个匿名函数，它可以包含表达式和语句，并且可用于创建委托或表达式目录树类型。所有 Lambda 表达式都使用 Lambda 运算符 =>，该运算符读为"goes to"。该 Lambda 运算符的左边是输入参数（如果有），右边包含表达式或语句块。

Lambda 表达式 x => x * x 读作"x goes to x times x"。可以将此表达式分配给委托类型。
Lambda表达式特性

Lambda内部可以使用静态、非静态和局部变量，这称为lambda内的变量捕获。
Lambda表达式在Java中又称为闭包或匿名函数。
Lambda表达式有个限制，那就是只能引用 final 或 final 局部变量，这就是说不能在lambda内部修改定义在域外的变量。

Lambda表达式应用

Stream 与 parallelStream

首先我们讲顺序执行流与并行执行流

顺序执行使用方式如下

List lists = list.stream().filter("1"::equals).collect(Collectors.toList());

并行执行使用方式如下

Liststrings = list.parallelStream().filter("1"::equals).collect(Collectors.toList());
ParallelStream 执行原理

Stream利用多核技术可将数据通过多核并行处理

// 数据分片

List list1 = list.subList(0, 1);

List list2 = list.subList(1, 2);

// 分片数据并发执行

new Thread(() -> list1.remove("2"));

new Thread(() -> list2.remove("2"));

list1.addAll(list2);

Stream 与ParallelStream 性能测试对比

long t0 = System.nanoTime();

//初始化一个范围1亿整数流,求能被2整除的数字，toArray()是终点方法

int a[]= IntStream.range(0, 100_000_000).filter(p -> p % 2==0).toArray();

long t1 = System.nanoTime();

//和上面功能一样，这里是用并行流来计算

int b[]=IntStream.range(0, 100_000_000).parallel().filter(p -> p % 2==0).toArray();

long t2 = System.nanoTime();

//我本机的结果是serial: 0.55s, parallel 0.26s，证明并行流确实比顺序流快

System.out.printf("serial: %.2fs, parallel %.2fs%n", (t1 - t0) * 1e-9, (t2 - t1) * 1e-9);

多核心机器，理论上并行流会比顺序流快上一倍

Stream API

Stream 常用方法
1. 匿名类简写

new Thread(() -> System.out.println()).start();

forEach

List list = Arrays.asList("1","2","3");

list.forEach(System.out::println);

Filter & Predicate

List list = Arrays.asList("1123","2","3");

Predicate startsWith1 = (n) -> n.startsWith("1");

Predicate startsWith2 = (n) -> n.length() ==4;

list.stream().filter(startsWith1.and(startsWith2)).forEach(System.out::println);

Map&Reduce

List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);

double bill = costBeforeTax.stream().map((cost) -> cost + 0.12*cost).reduce(Double::sum).get();

System.out.println("Total : " + bill);

Collectors

List G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");

String G7Countries=G7.stream().map(String::toUpperCase).collect(Collectors.joining(", "));

System.out.println(G7Countries);

flatMap(将多个stream流链接起来)

List result= Stream.of(Arrays.asList(1,3),Arrays.asList(5,6))

.flatMap(Collection::stream)

.collect(Collectors.toList());

Distinct

List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);

List collect = costBeforeTax.stream().map((cost) -> cost + 0.12*cost).distinct().collect(Collectors.toList());

Count

List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
Long collect = costBeforeTax.stream().map((cost) -> cost + 0.12*cost).distinct().count();

match(判断元素是否在列表存在)

List list = Arrays.asList(100, 200, 300, 400, 500);

// 全部匹配

boolean b = list.stream().allMatch(n -> n > 200);

// 列表中任意以元素匹配

boolean b1 = list.stream().allMatch(n -> n > 200);

// 列表中没有元素匹配

boolean b2 = list.stream().noneMatch(n -> n > 200);

mapToInt(聚合运算)

List list = Arrays.asList(100, 200, 300, 400, 500);

// 全部匹配

IntSummaryStatistics intSummaryStatistics = list.stream().mapToInt((x) -> x).summaryStatistics();

double average = intSummaryStatistics.getAverage();

long count = intSummaryStatistics.getCount();

int max = intSummaryStatistics.getMax();

int min = intSummaryStatistics.getMin();

long sum = intSummaryStatistics.getSum();

Peek(接收一个没有返回值的lambda表达式，可以做一些输出，外部处理等)

List list2 = lists.stream()

.filter(f -> f.getName().startsWith("p"))

.peek(t -> t.setAge(1L))

.map(Person::getAge)

.collect(Collectors.toList());

System.out.println(list2);
以上11中stream的用法都是我们编程中常见的使用方式，是否对大家有些许的帮助呢，当然还有很多这里没有提到的用法，需要大家深入了解了。

函数式编程总结
函数式编程的核心要素：传入参数，执行逻辑，返回值，也可以没有返回值。
函数式的编程风格侧重描述程序的执行逻辑，不是执行过程。
函数式编程也减少很多临时变量的创建，代码风格也变的简洁清楚。
不可变对象范式解决了并发编程中棘手问题（当程序的某些部分在多处理器同时运行时），意味着不同的处理器可以尝试同时修改同一块内存。
如果函数永远不会修改现有值而是产生新值，则不会对内存产生争用，这是函数式语言天生的优点。
函数式语言作为并行编程的其中之一的解决方案。