java8 函数式编程

1、简单的lamda表达式

如果一个接口中有多个方法，lamda不支持

interface A {
    void testA();
}

interface B {
    void testB(int x);
}

public class Test{

    public static void main(String[] args) {
        //不带参数的lamda表达式
        A a = ()->{ /*TODO*/  };
        //只有一条语句的lamda表达式
        B b = x -> System.out.println(x);
        //带参数的lamda表达式
        B b1 = (int x) -> { /*TODO*/ };
    }
}

2、流

public class Test{
    static ArrayList<Integer> list = new ArrayList<>();
    public static void main(String[] args) {
        for (int i = 0; i < 30; i++) {
            list.add(i);
        }
        //迭代器遍历
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()) {
            Integer data = iterator.next();
            if(data == 10) {
                System.out.println("find data==>"+10);
            }
        }
        //使用流进行遍历
        long count = list.stream().filter(data -> {
            if(data==10) {
                System.out.println("find data==>" + 10);
                return true;
            }
            return false;
        }).count();
        System.out.println("count==>"+count);
    }
}

以上都是遍历集合，查找并打印。
第一种使用迭代器操作
第二种使用流操作

filter为过滤方法，只是描述stream，但是不会做什么实质的工作。这种方法叫做懒性求值方法。
count会从stream产生值，叫做及早求值方法

2.1 一些常用的流操作

2.1.1
List<String> list = Stream.of("a", "b", "c").collect(Collectors.toList());
of方法将一组初始值生成新的Stream。
collect方法将Stream中的值生成一个集合。

2.1.2

public static void main(String[] args) {
        List<Integer> src = new ArrayList<>();
        for (int i = 0; i < 10; i++)
            src.add(i);

        List<String> dst = src.stream()
                .map(x -> String.valueOf(x))
                .collect(Collectors.toList());
    }

map中的参数其实是一个Function接口
map方法将参数从一种类型转换为另一种类型，这两种类型可以毫无关系。

2.1.3

List<Integer> dst = src.stream()
                .filter(x -> x<10)
                .collect(Collectors.toList());

filter的参数是Predicate接口，参数返回boolean。Stream值保留返回true的值。

2.1.4

import java.util.List;
import java.util.stream.Stream;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;

        List<Integer> list = Stream.of(asList(1, 2), asList(3, 4))
                .flatMap(numbers -> numbers.stream())
                .collect(toList());

flatmap将多个stream合并为一个stream

2.1.5

int min = Stream.of(1, 2, 3, 4, 5)
                .min(Comparator.comparing(x -> x))
                .get();

min/max 获取最小/最大值，需要实现Comparator接口

2.1.6

int count = Stream.of(1, 2, 3, 4, 5)
        .reduce(0, (acc, element) -> acc+element);

reduce可以将一组值生成一个值，count，min, max都是reduce的一种。

需要注意的是在lamda函数其实是接口，会设计内部方法自动添加final字段

3.1 基本类型

IntSummaryStatistics res = list.stream().mapToInt(x -> x).summaryStatistics();
res.getSum();
res.getMax();

lamda封装了基本类型的操作，可以使用mapToxxx方法进行具体的转换。
调用summaryStatistics方法将返回xxxSummaryStatistics.里面封装了具体的求最大值、最小值、和、平均值等操作。

3.2 @FunctionalInterface

FunctionalInterface注解用于标识lamda接口，将代码块作为数据打包起来。
该注解会强制javac检查一个接口是否符合lamda函数接口的标准。如果该注解添加在枚举、类、另一个注解或者接口不止一个抽象方法，javac会报错。重构代码时，可以很容易发现问题。

3.3 方法引用

//data为Model类型
l//amda表达式片段为
data -> data.get();
//等价于
Model::get

3.4 collect收集器

3.4.1
LinkedBlockingQueue res = list.stream().collect(Collectors.toCollection(LinkedBlockingQueue::new));

Collectors.toCollection方法可以将集合转换为任意Set或Collectoion的子类

3.4.2
求值操作，如求最大值、最小值、平均值。需要注意返回类型。求值操作可以有具体的类型，如averagingInt、averagingXXX

class Model {
    private int data;
    public int getData() {
        return data;
    }
    public Model(int data){
        this.data = data;
    }
}
public class Test{
    public static void main(String[] args) {
        List<Model> list = new ArrayList<>();
        for (int i = 0; i < 10; i++)
            list.add(new Model(i));
        //平均值
        double res = list.stream().collect(Collectors.averagingInt(Model::getData));
        //求最大值
        Optional<Model> d = list.stream().collect(maxBy(comparing(Model::getData)));
    }
}

3.4.3

Map<Boolean, List<Model>> res = list.stream().collect(partitioningBy(x -> x.getData() > 5));

partitioningBy可以将一个集合按照条件分割成多个集合

3.4.4
组合收集器，可以将多个操作组合使用。

Map<Integer, Long> res = list.stream().collect(groupingBy(x -> x.getData(), counting()));

groupingBy可以将两个操作一起返回。
x -> x.getData()对应Map的Integer，counting()对应Map的Long

4、并行流处理

普通流调用parallel()或集合调用parallelStream()即可获得一个拥有并行能力的流。

并行处理的性能
数据的大小：并行处理是将数据分割、处理、合并。数据量足够大才能充分体现效率。
源数据结构：
ArrayList、数组或者IntStream支持随机读取的数据结构容易分割。性能较好
HashSet、TreeSet这些不容易分割，但是可以分割。性能一般
LinkedList、Streams.iterate等需要O(N)时间复杂度来分解问题，性能较差
装箱：基本类型比装箱类型效果好
cpu核心数：核心越多，效果越好
单元处理开销：花在流中每个元素的时间越长，效果越好

4.1 并行化数组操作

Arrays.parallelPrefix   //计算数组的和
Arrays.parallelSetAll   //更新数组元素
Arrays.parallelSort     //并行化对数组元素排序

5、调试

使用peek方法可以用于调试打印,不会影响正常的操作
list.stream().peek(natie -> System.out.println("==>"+natie.getData())).count();