（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，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，返回新元素。
userList.stream()
          .map(User::getName)
          .forEach(System.out::println);
//结果
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进行分区