首先对stream的操作可以分为两类，中间操作(intermediate operations)和结束操作(terminal operations):

  • 中间操作总是会惰式执行，调用中间操作只会生成一个标记了该操作的新stream。
  • 结束操作会触发实际计算，计算发生时会把所有中间操作积攒的操作以pipeline的方式执行，这样可以减少迭代次数。计算完成之后stream就会失效。

虽然大部分情况下stream是容器调用Collection.stream()方法得到的，但stream和collections有以下不同：

  • 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
  • 为函数式编程而生。对stream的任何修改都不会修改背后的数据源，比如对stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新stream。
  • 惰式执行。stream上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。
  • 可消费性。stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。

     

一、获取stream

  1.  
    // 1、数组
  2.  
    String[] arr = new String[]{"ab", "cd", "ef"};
  3.  
    Stream<String> arrStream = Arrays.stream(arr);
  4.  
    // 2、集合
  5.  
    List<String> list = Arrays.asList("ab", "cd", "ef");
  6.  
    Stream<String> colStream = list.stream();
  7.  
    // 3、值
  8.  
    Stream<String> stream = Stream.of("ab", "cd", "ef");

二、stream方法使用

测试数据：

  1.  
    List<User> list = Arrays.asList(
  2.  
    // name，age
  3.  
    new User("张三", 11),
  4.  
    new User("王五", 20),
  5.  
    new User("王五", 91),
  6.  
    new User("张三", 8),
  7.  
    new User("李四", 44),
  8.  
    new User("李四", 44),
  9.  
    new User("李四", 44)
  10.  
    );

1、forEach() 使用该方法迭代流中的每个数据

  1.  
    /**
  2.  
    * forEach 迭代输出每条数据.
  3.  
    */
  4.  
    @Test
  5.  
    public void testForEach(){
  6.  
    // java 8 前
  7.  
    System.out.println("java 8 前");
  8.  
    for(User user: list){
  9.  
    System.out.println(user);
  10.  
    }
  11.  
    // java 8 lambda
  12.  
    System.out.println("java 8 lambda");
  13.  
    list.forEach(user -> System.out.println(user));
  14.  
     
  15.  
    // java 8 stream lambda
  16.  
    System.out.println("java 8 stream lambda");
  17.  
    list.stream().forEach(user -> System.out.println(user));
  18.  
    }

console->

2、sorted() 使用该方法排序数据

  1.  
    /**
  2.  
    * sort 排序.
  3.  
    */
  4.  
    @Test
  5.  
    public void testSort() {
  6.  
    System.out.println("-----排序前-----");
  7.  
    list.forEach(user -> System.out.println(user));
  8.  
    System.out.println("-----排序后-----");
  9.  
    // java 8 前
  10.  
    System.out.println("java 8 前");
  11.  
    Collections.sort(list, new Comparator<User>() {
  12.  
    @Override
  13.  
    public int compare(User o1, User o2) {
  14.  
    return o1.getAge().compareTo(o2.getAge());
  15.  
    }
  16.  
    });
  17.  
    for (User user : list) {
  18.  
    System.out.println(user);
  19.  
    }
  20.  
    // java 8 stream 方法引用
  21.  
    System.out.println("java 8 stream 方法引用");
  22.  
    list.stream().sorted(Comparator.comparing(User::getAge)).forEach(user -> System.out.println(user));
  23.  
    }

console->

3、filter()：使用该方法过滤

  1.  
    /**
  2.  
    * filter 过滤.
  3.  
    */
  4.  
    @Test
  5.  
    public void testFilter() {
  6.  
    // 输出年龄大于50的人
  7.  
    System.out.println("-----过滤前-----");
  8.  
    list.forEach(user -> System.out.println(user));
  9.  
    System.out.println("-----过滤后-----");
  10.  
    // java 8 前
  11.  
    System.out.println("java 8 前");
  12.  
    for(User user: list){
  13.  
    if (user.getAge() > 50) {
  14.  
    System.out.println(user);
  15.  
    }
  16.  
    }
  17.  
    // java 8 stream
  18.  
    System.out.println("java 8 stream");
  19.  
    list.stream().filter((User user) -> user.getAge() > 50).forEach(user -> System.out.println(user));
  20.  
    }

console->

4、limit()：使用该方法截断

  1.  
    /**
  2.  
    * limit 截断.
  3.  
    */
  4.  
    @Test
  5.  
    public void testLimit() {
  6.  
    // 从第三个开始截断，只输出前三个
  7.  
    System.out.println("-----截断前-----");
  8.  
    list.forEach(user -> System.out.println(user));
  9.  
    System.out.println("-----截断后-----");
  10.  
    // java 8 前
  11.  
    System.out.println("java 8 前");
  12.  
    for (int i = 0; i < 3; i++) {
  13.  
    System.out.println(list.get(i));
  14.  
    }
  15.  
    // java 8 stream
  16.  
    System.out.println("java 8 stream");
  17.  
    list.stream().limit(3).forEach(user -> System.out.println(user));
  18.  
    }

console->

5、skip()：与limit互斥，使用该方法跳过元素

  1.  
    /**
  2.  
    * skip 跳过.
  3.  
    */
  4.  
    @Test
  5.  
    public void testSkip() {
  6.  
    // 跳过前三个元素，从第四个开始输出
  7.  
    System.out.println("-----跳过前-----");
  8.  
    list.forEach(user -> System.out.println(user));
  9.  
    System.out.println("-----跳过后-----");
  10.  
    // java 8 前
  11.  
    System.out.println("java 8 前");
  12.  
    for (int i = 3; i < list.size(); i++) {
  13.  
    System.out.println(list.get(i));
  14.  
    }
  15.  
    // java 8 stream
  16.  
    System.out.println("java 8 stream");
  17.  
    list.stream().skip(3).forEach(user -> System.out.println(user));
  18.  
    }

console->

6、distinct()：使用该方法去重，注意：必须重写对应泛型的hashCode()和equals()方法

  1.  
    /**
  2.  
    * distinct 去重.
  3.  
    */
  4.  
    @Test
  5.  
    public void testDistinct() {
  6.  
    // 因为Arrays.asList() 返回的是Arrays的内部类ArrayList，操作remove，add会报错
  7.  
    List<User> users = new ArrayList(list);
  8.  
    // 为list去除重复数据
  9.  
    System.out.println("-----去重前-----");
  10.  
    list.forEach(user -> System.out.println(user));
  11.  
    System.out.println("-----去重后-----");
  12.  
    // java 8 前
  13.  
    System.out.println("java 8 前");
  14.  
    for (int i = 0; i < users.size() - 1; i++) {
  15.  
    for (int j = users.size() - 1; j > i; j--) {
  16.  
    if (users.get(j).getAge() == users.get(i).getAge() && users.get(j).getName()
  17.  
    .equals(users.get(i).getName())) {
  18.  
    users.remove(i);
  19.  
    }
  20.  
    }
  21.  
    }
  22.  
    for (User user : users) {
  23.  
    System.out.println(user);
  24.  
    }
  25.  
    // java 8 stream
  26.  
    System.out.println("java 8 stream");
  27.  
    users.stream().distinct().forEach(user -> System.out.println(user));
  28.  
    }

console->

***根据上述方法，完成去重+按照年龄大于40以后从小到大+只取前二

  1.  
    /**
  2.  
    * 去重+按照年龄大于40以后从小到大+只取前二
  3.  
    */
  4.  
    @Test
  5.  
    public void demo() {
  6.  
    list.stream().distinct().filter(user -> user.getAge() > 40).sorted(
  7.  
    Comparator.comparing(User::getAge)).limit(2).forEach(user -> System.out
  8.  
    .println(user));
  9.  
    }

console->

7、max，min，sum，avg，count 

  1.  
    /**
  2.  
    * 测试计算.
  3.  
    */
  4.  
    @Test
  5.  
    public void testNum() {
  6.  
    IntSummaryStatistics num = list.stream().mapToInt(u -> u.getAge())
  7.  
    .summaryStatistics();
  8.  
    System.out.println("总共人数：" + num.getCount());
  9.  
    System.out.println("平均年龄：" + num.getAverage());
  10.  
    System.out.println("最大年龄：" + num.getMax());
  11.  
    System.out.println("最小年龄：" + num.getMin());
  12.  
    System.out.println("年龄之和：" + num.getSum());
  13.  
    }

console->

8、map()：接收一个方法作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素

  1.  
    /**
  2.  
    * map 映射.
  3.  
    */
  4.  
    @Test
  5.  
    public void testMap() {
  6.  
    // 只输出所有人的年龄
  7.  
    list.stream().forEach(user -> System.out.println(user));
  8.  
    System.out.println("映射后----->");
  9.  
    List<Integer> ages = list.stream().map(user -> user.getAge()).collect(toList());
  10.  
    ages.forEach(age -> System.out.println(age));
  11.  
     
  12.  
    // 小写转大写
  13.  
    List<String> words = Arrays.asList("aaa", "vvvv", "cccc");
  14.  
    System.out.println("全部大写---->");
  15.  
    List<String> collect = words.stream().map(s -> s.toUpperCase()).collect(toList());
  16.  
    collect.forEach(s -> System.out.println(s));
  17.  
    }

console->

9、flatMap()：对每个元素执行mapper指定的操作，并用所有mapper返回的Stream中的元素组成一个新的Stream作为最终返回结果，通俗易懂就是将原来的stream中的所有元素都展开组成一个新的stream

  1.  
    /**
  2.  
    * flatMap .
  3.  
    */
  4.  
    @Test
  5.  
    public void testFlatMap() {
  6.  
    //创建一个 装有两个泛型为integer的集合
  7.  
    Stream<List<Integer>> stream = Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(4, 5));
  8.  
    // 将两个合为一个
  9.  
    Stream<Integer> integerStream = stream.flatMap(
  10.  
    (Function<List<Integer>, Stream<Integer>>) integers -> integers.stream());
  11.  
    // 为新的集合
  12.  
    List<Integer> collect = integerStream.collect(toList());
  13.  
    System.out.println("新stream大小:"+collect.size());
  14.  
    System.out.println("-----合并后-----");
  15.  
    collect.forEach(o -> System.out.println(o));
  16.  
    }

console->

10、findFirst() ：使用该方法获取第一个元素

  1.  
    /**
  2.  
    * findFirst 获取第一个元素.
  3.  
    */
  4.  
    @Test
  5.  
    public void testFindFirst(){
  6.  
    User user = list.stream().findFirst().get();
  7.  
    System.out.println(user);
  8.  
    }

console->

 

转载自：https://blog.csdn.net/chenhao_c_h/article/details/80691284