函数式编程（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 常用方法
- 匿名类简写
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的用法都是我们编程中常见的使用方式，是否对大家有些许的帮助呢，当然还有很多这里没有提到的用法，需要大家深入了解了。
- 函数式编程总结
- 函数式编程的核心要素：传入参数，执行逻辑，返回值，也可以没有返回值。
- 函数式的编程风格侧重描述程序的执行逻辑，不是执行过程。
- 函数式编程也减少很多临时变量的创建，代码风格也变的简洁清楚。
- 不可变对象范式解决了并发编程中棘手问题（当程序的某些部分在多处理器同时运行时），意味着不同的处理器可以尝试同时修改同一块内存。
- 如果函数永远不会修改现有值而是产生新值，则不会对内存产生争用，这是函数式语言天生的优点。
- 函数式语言作为并行编程的其中之一的解决方案。