函数式编程

函数式编程（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的用法都是我们编程中常见的使用方式，是否对大家有些许的帮助呢，当然还有很多这里没有提到的用法，需要大家深入了解了。