Stream流使用（Lamdba表达式重点场景）

1、什么是Stream流？

java8中的stream使用的是函数式编程模式，如同它的名字一样，它可以被用来对集合或数组进行链状流式的操作，可以更方便的我们对集合或数组操作。

例子：

// 如下例所示，简化了对集合的操作
Integer[] intArray = new Integer[]{2,3,4,5,6,7};
// 创建Stream流对象
Stream<Integer> intStream = Stream.of(intArray);
intStream.distinct()//去重（中间操作）
        .filter(ele -> ele > 4)//过滤（中间操作）
        .forEach(ele -> System.out.println(ele));（终结操作）

2、如何使用Stream流？

公式：创建流 + 中间操作 + 终结操作

(必须要有终结操作，前面的中间操作才会执行)

1）创建流（备注：Collection接口实现类为单列集合，如List和Set；Map接口实现类为双列集合，如Map）

　　类型一：单列集合：集合对象.stream()

1 2	`List<Integer> integerList =` `new` `ArrayList<>();` `Stream<Integer> stream = integerList.stream();`

　　类型二：数组：Arrays.stream(数组)或者使用Stream.of来创建

Integer[] intArray = new Integer[]{2,3,4,5,6,7};
Stream<Integer> intStream = Stream.of(intArray);
intStream = Arrays.stream(intArray);

　　类型三：双列集合：转换成单列集合后创建

1 2	`Map<String,Object> map =` `new` `HashMap<>();` `Stream<Map.Entry<String,Object>> mapStream = map.entrySet().stream();`

2）中间操作

filter( ) // 用作过滤集合元素

map( ) // 修改流中的对象指定，可以指定为流中对象的属性（非集合属性）

List<Person> integerList = new ArrayList<>();
integerList.add(new Person("xiaoming", 2));
Stream<Person> stream = integerList.stream();
stream.distinct() // 流，在这里的时候还是Person对象
      .map(new Function<Person, String>() {
          // 经过map方法之后，转化为name了
    @Override
    public String apply(Person person){
        return person.name;
    }
}).forEach(new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
});
 
// lambda格式
Stream<Person> stream = integerList.stream();
// 经过map方法之后，转化为name了
stream.distinct() // 流，在这里的时候还是Person对象
      .map(person -> person.name)
        .forEach(s -> System.out.println(s));

distinct( ) // 去重，一般需要重写对象的equals方法

sorted( ) // 排序

List<Person> integerList = new ArrayList<>();
integerList.add(new Person("xiaoming", 2));
Stream<Person> stream = integerList.stream();
stream.sorted(((o1, o2) -> o1.age - o2.age))
        .forEach(s -> System.out.println(s));

limit( ) // 可以设置流的最大长度，超出部分将被抛弃

skip( ) // 跳过流中的前n个元素，返回剩下的元素

flatMap( ) //修改流中的对象指定，可以指定为流中对象的属性（集合属性）

// 如下，统计Person list里面所有的book数量
List<Person> integerList = new ArrayList<>();
integerList.add(new Person("xiaoming", 2));
Stream<Person> stream = integerList.stream();
stream.flatMap(new Function<Person, Stream<?>>() {
            @Override
            public Stream<?> apply(Person person) {
                return person.books.stream();
            }
        })
        .forEach(s -> System.out.println(s));
 
// lambda格式
stream.flatMap((Function<Person, Stream<?>>) person -> person.books.stream())
        .forEach(s -> System.out.println(s));

3）终结操作

forEach( ) // 对流中的元素进行遍历

count( ) // 获取流中的元素个数

max( ) // 获取流中的最大值

min( ) // 获取流中的最小值

collect( ) // 将流转化为一个集合

// 展示collect的使用方式
List<Person> integerList = new ArrayList<>();
integerList.add(new Person("xiaoming", 2));
Stream<Person> stream = integerList.stream();
//List<Person> list = stream.collect(Collectors.toList());
//Set<Person> set = stream.collect(Collectors.toSet());
Map<String,Object> map = stream.collect(Collectors.toMap(person -> person.name, person -> person.books));

anyMatch( ) // 判断任意是否匹配

allMatch( ) // 判断是否全部匹配

noneMatch( ) // 判断是否全部不匹配

findAny( ) // 获取任意一个元素

findFirst( ) // 获取第一个元素

List<Person> integerList = new ArrayList<>();
integerList.add(new Person("xiaoming", 2));
Stream<Person> stream = integerList.stream();
stream.findFirst()
        .ifPresent(person -> System.out.println(person.name));

reduce( ) // 归并，reduce的作用是把stream中的元素给组合起来，我们可以传入一个初始值，它会按照我们的计算方式依次拿流中的元素和在初始化值的基础上进行计算，计算结果再和后面的元素计算。

List<Person> integerList = new ArrayList<>();
integerList.add(new Person("xiaoming", 2));
Stream<Person> stream = integerList.stream();
// 统计所有person的年龄
Integer sum = stream.map(person -> person.age)
        .reduce(0, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer result, Integer element) {
                return result + element;
            }
        });
// lambda
// 统计所有person的年龄
Integer sum = stream.map(person -> person.age)
        .reduce(0, (result, element) -> result + element);