Java8 Lamba Steam操作

（1）、创建Stream ：一个数据源（如：集合、数组），获取一个流

（2）、中间操作：一个中间操作链，对数据源的数据进行处理

（3）、终止操作（终端操作）：一个终止操作，执行中间操作链，并产生结果

1、生成流

// 由Collection创建流
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
// 由数组创建流
Employee[] emps = new Employee[10];
Stream<Employee> stream2 = Arrays.stream(emps);

2、中间操作

filter--接收 Lambda，从流中排除某些元素

private static List<User> initList() {
        List<User> userList = new ArrayList<>();
        userList.add(new User("1", "xiaom", 18, 3500, "0"));
        userList.add(new User("2", "shany", 20, 13500, "0"));
        userList.add(new User("3", "damao", 35, 7000, "0"));
        userList.add(new User("4", "guoer", 17, 6500, "1"));
        userList.add(new User("5", "longn", 18, 4500, "0"));
        userList.add(new User("6", "guoer", 25, 9200, "1"));
        return userList;
}
 
List<User> userList = initList();
         
userList.stream()
         .filter((e) -> e.getAge() > 18)
         .forEach(System.out::println);
// 结果
User{id='2', name='shany', age=20, status=0}
User{id='3', name='damao', age=35, status=0}
User{id='6', name='guoer', age=25, status=1}

limit--截断流，使其元素不超过给定数量

userList.stream()
          .filter((e) -> e.getAge() > 18)
          .limit(2)
          .forEach(System.out::println);
// 结果
User{id='2', name='shanyu', age=20, status=0}
User{id='3', name='damao', age=35, status=0}

skip(n)--跳过元素，返回一个扔掉了前n个元素的流

userList.stream()
          .filter((e) -> e.getAge() > 18)
          .skip(1)
          .limit(1)
          .forEach(System.out::println);
// 结果
User{id='3', name='damao', age=35, status=0}

distinct--筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

userList.stream()
          .distinct()
          .forEach(System.out::println);
// 结果，去重name=guoer
User{id='1', name='xiaoming', age=18, status=0}
User{id='2', name='shanyu', age=20, status=0}
User{id='3', name='damao', age=35, status=0}
User{id='4', name='guoer', age=17, status=1}
User{id='5', name='longnv', age=18, status=0}

map--接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，返回新元素。

?
1
2
3
4
userList.stream()
.map(User::getName)
.forEach(System.out::println);
//结果<br>XIAOMING SHANYU DAMAO GUOER LONGNV GUOER

peek--返回由该流的元素组成的流，并对每个元素执行所提供的Consumer操作方法。

userList.stream()
          .peek(e -> e.setName(e.getName().toUpperCase()))
          .forEach(System.out::println);
// 结果
User{id='1', name='XIAOMING', age=18, status=0}
User{id='2', name='SHANYU', age=20, status=0}
User{id='3', name='DAMAO', age=35, status=0}
User{id='4', name='GUOER', age=17, status=1}
User{id='5', name='LONGNV', age=18, status=0}
User{id='6', name='GUOER', age=25, status=1}

sorted(Comparator com)----定制排序（Comparator）

List<String> list = Arrays.asList("ccc", "aaa", "bbb", "ddd", "eee");
        list.stream()
                .sorted()
                .forEach(System.out::println);
 
        System.out.println("=======定制排序=========");
 
        List<User> userList = initList();
        userList.stream()
                .sorted((x, y) -> {
                    if (x.getAge() == y.getAge()) {
                        return x.getName().compareTo(y.getName());
                    } else {
                        return Integer.compare(x.getAge(), y.getAge());
                    }
                }).forEach(System.out::println);
// 结果
aaa
bbb
ccc
ddd
eee
=======定制排序=========
User{id='4', name='guoer', age=17, status=1}
User{id='5', name='longnv', age=18, status=0}
User{id='1', name='xiaoming', age=18, status=0}
User{id='2', name='shanyu', age=20, status=0}
User{id='6', name='guoer', age=25, status=1}
User{id='3', name='damao', age=35, status=0}

3、终止操作

allMatch——检查是否匹配所有元素
anyMatch——检查是否至少匹配一个元素
noneMatch——检查是否没有匹配的元素
findFirst——返回第一个元素
findAny——返回当前流中的任意元素
count——返回流中元素的总个数
max——返回流中最大值
min——返回流中最小值
reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。

Collector接口中方法的实现决定了如何对流执行收集操作（如收集到List、Set、Map）。但是Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表

方法	返回类型	作用
toList	List<T>	把流中元素收集到List
toSet	Set<T>	把流中元素收集到Set
toCollection	Conllection<T>	把流中元素收集到创建的集合
counting	Long	计算流元素中的个数
summingInt	Integer	对流中元素的整数属性求和
avargingInt	Double	计算流中元素Integer属性的平均值
summarizingInt	IntSummaryStatistics	收集流中Integer属性的统计值,如平均值
joining	String	连接流中的每个字符串
maxBy	Optional<T>	根据比较器选择最大值
minBy	Optional<T>	根据比较器选择最小值
reducing	归约产生的类型	从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值
collectingAndThen	转换函数返回的类型	包裹另一个收集器，对其结果转换函数
groupingBy	Map<K, List<T>>	根据某属性值对流分组，属性为K，结果为V
partitioningBy	Map<Boolean, List<T>>	根据true或者false进行分区