JDK8新特性——Stream API

旧城等待， 2022-12-13 01:18 233阅读 0赞

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API。Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，负责存储数据，Stream流讲的是计算，负责处理数据！”

注意：  
①Stream 自己不会存储元素。  
②Stream 不会改变源对象。每次处理都会返回一个持有结果的新Stream。  
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤：

1.  创建 Stream：通过一个数据源（如：集合、数组），获取一个流
2.  中间操作：中间操作是个操作链，对数据源的数据进行n次处理，但是在终结操作前，并不会真正执行。
3.  终止操作：一旦执行终止操作，就执行中间操作链，最终产生结果并结束Stream。  
    ![在这里插入图片描述][20201008201215518.png_pic_center]

# 1、创建Stream流 #

### 1.创建Stream方式一:通过集合 ###

Java8中的Collection接口被扩展，提供了两个获取流的方法:

●default Stream stream() : 返回一个顺序流

●default Stream parallelStream() : 返回一个并行流

### 2.创建Stream方式二:通过数组 ###

Java8中的Arrays的静态方法stream()可以获取数组流:

● static Stream stream(T\[\] array): 返回一个流

重载形式，能够处理对应基本类型的数组:

●public static IntStream stream(int\[\] array)：返回一个整型数据流

●public static LongStream stream(long\[\] array)：返回一个长整型数据流

●public static DoubleStream stream(double\[\] array)：返回一个浮点型数据流

### 3.创建Stream方式三:通过Stream的of() ###

可以调用Stream类静态方法of()，通过显示值创建一个流。它可以接受任意数量的参数

●public static Stream of(T… values) : 返回一个顺序流

### 4.创建Stream方式四:创建无限流 ###

可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。

●public static Stream iterate(final T seed, final UnaryOperator f):返回一个无限流

● public static Stream generate(Supplier s) ：返回一个无限流

示例代码：

package com.bdit.stream;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Stream;
    
    public class TestCreateStream {
        
        public void test1() {
        
            List<String> list = Arrays.asList("hello", "world", "java", "lambda", "stream");
            // 创建stream
            Stream<String> stream = list.stream();
            // 终结遍历stream流中的数据
            stream.forEach(System.out::println);
        }
        
        public void test2() {
        
            String[] array = {
         "hello", "world", "java", "lambda", "stream" };
            // 创建stream
            Stream<String> stream = Arrays.stream(array);
            // 终结遍历stream流中的数据
            stream.forEach(System.out::println);
        }
        
        public void test3() {
        
            // 创建stream
            Stream<String> stream = Stream.of("hello", "world", "java", "lambda", "stream");
            // 终结遍历stream流中的数据
            stream.forEach(System.out::println);
        }
        
        public void test4() {
        
            // 创建stream，由奇数组成
            Stream<Integer> stream = Stream.iterate(1, num->num+2);
            // 终结遍历stream流中的数据
            stream.forEach(System.out::println);
        }
    }

# 2、中间处理数据操作 #

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>filter(Predicate p)</td> 
   <td>接收 Lambda ， 从流中排除某些元素</td> 
  </tr> 
  <tr> 
   <td>distinct()</td> 
   <td>筛选，通过流所生成元素的equals() 去除重复元素</td> 
  </tr> 
  <tr> 
   <td>limit(long maxSize)</td> 
   <td>截断流，使其元素不超过给定数量</td> 
  </tr> 
  <tr> 
   <td>skip(long n)</td> 
   <td>跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补</td> 
  </tr> 
  <tr> 
   <td>peek(Consumer action)</td> 
   <td>接收Lambda，对流中的每个数据执行Lambda体操作</td> 
  </tr> 
  <tr> 
   <td>sorted()</td> 
   <td>产生一个新流，其中按自然顺序排序</td> 
  </tr> 
  <tr> 
   <td>sorted(Comparator com)</td> 
   <td>产生一个新流，其中按比较器顺序排序map(Function f)</td> 
  </tr> 
  <tr> 
   <td>mapToDouble(ToDoubleFunction f)</td> 
   <td>接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。</td> 
  </tr> 
  <tr> 
   <td>mapToInt(ToIntFunction f)</td> 
   <td>接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。</td> 
  </tr> 
  <tr> 
   <td>mapToLong(ToLongFunction f)</td> 
   <td>接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。</td> 
  </tr> 
  <tr> 
   <td>flatMap(Function f)</td> 
   <td>接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流</td> 
  </tr> 
 </tbody> 
</table>

**1、示例代码：找出流所有偶数，并且要求不重复**

public void test1(){
        
            //取出所有偶数，并且要求不重复
            Stream.of(1,1,3,3,4,4,6,6)
            .filter(num -> num%2==0)
            .distinct()
            .forEach(System.out::println);
    }

**2、示例代码：随机产生10个100以内整数，遍历显示，并找出最大值**

public void test2(){
        
            //随机产生10个100以内整数，遍历显示，并找出最大值
            Random random = new Random();
            Optional<Integer> max = Stream.generate(() -> random.nextInt(100))
            .limit(10)
            .peek(System.out::println)
            .max(Integer::compareTo);
            System.out.println("max = " + max.get());
    }

**3、示例代码：按照薪资排序**

public void test3(){
        
            //按照薪资排序
            ArrayList<Employee> list = new ArrayList<>();
            list.add(new Employee("张三",8888));
            list.add(new Employee("李四",9999));
            list.add(new Employee("王五",10000));
            list.add(new Employee("赵六",11111));
            list.add(new Employee("钱七",7777));
    
            list.stream()
            .sorted((e1,e2)->e1.getSalary()==e2.getSalary()?0:(int)Math.ceil(e1.getSalary()-e2.getSalary()))
            .forEach(System.out::println);
    }

**4、示例代码：给每个员工涨薪10%**

public void test4(){
        
            //给每个员工涨薪10%
            ArrayList<Employee> list = new ArrayList<>();
            list.add(new Employee("张三",8888));
            list.add(new Employee("李四",9999));
            list.add(new Employee("王五",10000));
            list.add(new Employee("赵六",11111));
            list.add(new Employee("钱七",7777));
    
            list.stream()
            .map(e->{
        e.setSalary(e.getSalary()*1.1);return e;})
            .forEach(System.out::println);
    }

**5、示例代码：求每个数的平方根**

public void test5(){
        
            //求每个数的平方根
            Stream.of(4,9,16,25,49)
            .mapToDouble(num -> Math.sqrt(num))
            .forEach(System.out::println);
    }

**6、示例代码：把首字母变成大写**

public void test6(){
        
            //把首字母变成大写
            Stream.of("hello","world","java","stream").
            map(s -> Character.toUpperCase(s.charAt(0)) + s.substring(1))
            .forEach(System.out::println);
    }

**7、示例代码：把每个单词拆成一个个字母**

public void test7(){
        
            //把每个单词拆成一个个字母
            Stream.of("hello","world","java","stream")
            .flatMap(t -> Stream.of(t.split("|")))
            .forEach(System.out::println);
    }

# 3、终结操作 #

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void。流进行了终止操作后，不能再次使用。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean allMatch(Predicate p)</td> 
   <td>检查是否匹配所有元素</td> 
  </tr> 
  <tr> 
   <td>boolean anyMatch(Predicate p)</td> 
   <td>检查是否至少匹配一个元素</td> 
  </tr> 
  <tr> 
   <td>boolean noneMatch(Predicate p)</td> 
   <td>检查是否没有匹配所有元素</td> 
  </tr> 
  <tr> 
   <td>Optional findFirst()</td> 
   <td>返回第一个元素</td> 
  </tr> 
  <tr> 
   <td>Optional findAny()</td> 
   <td>返回当前流中的任意元素</td> 
  </tr> 
  <tr> 
   <td>long count()</td> 
   <td>返回流中元素总数</td> 
  </tr> 
  <tr> 
   <td>Optional max(Comparator c)</td> 
   <td>返回流中最大值</td> 
  </tr> 
  <tr> 
   <td>Optional min(Comparator c)</td> 
   <td>返回流中最小值</td> 
  </tr> 
  <tr> 
   <td>void forEach(Consumer c)</td> 
   <td>迭代</td> 
  </tr> 
  <tr> 
   <td>T reduce(T iden, BinaryOperator b)</td> 
   <td>可以将流中元素反复结合起来，得到一个值。返回 T</td> 
  </tr> 
  <tr> 
   <td>U reduce(BinaryOperator b)</td> 
   <td>可以将流中元素反复结合起来，得到一个值。返回 Optional</td> 
  </tr> 
  <tr> 
   <td>R collect(Collector c)</td> 
   <td>将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法</td> 
  </tr> 
 </tbody> 
</table>

Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。

**1、代码示例：是否所有员工的薪资都低于2000**

public void test1(){
        
            ArrayList<Employee> empList=new ArrayList<>();
            empList.add(new Employee(1001,"张三",999));
            empList.add(new Employee(1002,"李四",1999));
            empList.add(new Employee(1003,"王五",2999));
            empList.add(new Employee(1004,"小明",3999));
            empList.add(new Employee(1005,"大米",899));
            //判断是否所有员工的薪水小于2000
            boolean flag=empList.stream().allMatch(e->e.getMoney()<5000);
            System.out.println("是否所有员工的薪水小于2000"+flag);
    }

**2、示例代码：是否有员工薪资低于2000**

public void test2(){
        
            //判断是否有员工的薪水小于2000
            boolean result=empList.stream().anyMatch(e->e.getMoney()<2000);
            System.out.println("是否有员工的薪水小于2000"+result);
    }

**3、代码示例：薪资最高的员工**

public void test3(){
        
            ArrayList<Employee> list = new ArrayList<>();
            list.add(new Employee("张三",8888));
            list.add(new Employee("李四",9999));
            list.add(new Employee("王五",10000));
            list.add(new Employee("赵六",11111));
            list.add(new Employee("钱七",7777));
    
            Optional<Employee> max = list.stream()
            .max((e1,e2)->e1.getSalary()==e2.getSalary()?0:(int)Math.ceil(e1.getSalary()-e2.getSalary()));
            System.out.println("薪资最高的员工是：" + max.get());
    }

**4、代码示例：求累加和**

public void test4(){
        
            Optional<Integer> sum = Stream.of(1,2,3,4,5,6,7,8,9,10)
            .reduce((t1,t2) -> t1+t2);
            System.out.println("和：" + sum.get());
    }

**5、代码示例：找出薪资高于10000的员工放到新的List集合中**

public void test5(){
        
            ArrayList<Employee> list = new ArrayList<>();
            list.add(new Employee("张三",8888));
            list.add(new Employee("李四",9999));
            list.add(new Employee("王五",10000));
            list.add(new Employee("赵六",11111));
            list.add(new Employee("钱七",7777));
    
            List<Employee> collect = list.stream().
            filter(e->e.getSalary()>10000)
            .collect(Collectors.toList());
    
            collect.forEach(System.out::println);
    }

**6、示例代码：按照男女分组**

public void test6(){
        
            ArrayList<Student> list = new ArrayList<>();
            list.add(new Student("张三",'男'));
            list.add(new Student("李四",'女'));
            list.add(new Student("王五",'男'));
            list.add(new Student("赵六",'女'));
            list.add(new Student("钱七",'男'));
    
            Map<Character, List<Student>> collect = list.stream()
            .collect(Collectors.groupingBy(s -> s.getGender()));
    
            collect.forEach((k,v) -> System.out.println(k+"->" + v));
    }

[20201008201215518.png_pic_center]: /images/20221123/656846fbbda14bd6a749ad06e8a6580a.png