Steam流详解

steam流

Java8 API添加了一个新的抽象称为流 Stream ，可以让
你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直
观方式来提供一种对 Java 集合运算和表达的高阶抽
象。Stream API可以极大提高Java程序员的生产力，让
程序员写出高效率、干净、简洁的代码。这种风格将要
处理的元素集合看作一种流， 流在管道中传输， 并且可
以在管道的节点上进行处理， 比如筛选， 排序，聚合
等。
1. Stream的操作三个步骤
1、创建Stream
一个数据源（如：集合、数组），获取一个流
2、中间操作
一个中间操作链，对数据源的数据进行处理
3、终止操作
一个终止操作，执行中间操作链，并产生结果
1.1. 创建Stream

public class TestStreamAPI1 {
  // 创建Stream
  public void test1() {
    // 1、可以通过Conllection系列集合提供的顺序
流stream()或并行流parallelStream()
    List<String> list = new ArrayList<>();
    Stream<String> stream1 =
list.stream();
    stream1 = list.parallelStream();
    // 2、通过Arrays中的静态方法stream()获取数
据流
    Integer ints[] = new Integer[10];
    Stream<Integer> stream2 =
Arrays.stream(ints);
    // 3、通过Stream类中的静态方法of()
    Stream<String> stream3 =
Stream.of("aa", "bb", "cc");
    String str[] = new String[10];
    Stream<String> stream4 =
Stream.of(str)
 }
}

1.2. Stream的中间操作
1.2.1. 筛选和切片
filter

List<Employee> emps = Arrays.asList(
  new Employee("张三", 18, 3333.33),
  new Employee("李四", 38, 4444.44),
  new Employee("王五", 50, 5555.55),
  new Employee("赵六", 16, 6666.66),
  new Employee("田七", 28, 7777.77)
);
// filter-接收Lambda，从流中排除某些元素
public void test1() {
  Stream<Employee> stream = emps.stream()
   .filter((e) -> {
      System.out.println("StreamAPI的中间
操作");
      return e.getAge() > 35;
   });
  // 终止操作：一次性执行全部内容，即“惰性求值”
  stream.forEach(System.out::println);
}

limit

// limit-截断流，使其元素不超过给定数量
public void test2() {
  emps.stream()
   .filter((e) -> e.getSalary() > 5000)
   .limit(2)
   .forEach(System.out::println);
}

skip

// skip-跳过元素，返回一个扔掉了前n个元素的流，若流中
元素不足n个，则返回一个空流。
public void test3() {
  emps.stream()
   .filter((e) -> e.getSalary() > 5000)
   .skip(2)
   .forEach(System.out::println);
}

distinct

// distinct-筛选，通过流所生产元素的hashCode()和
equals()去除重复元素
public void test4() {
  emps.stream()
   .filter((e) -> e.getSalary() > 5000)
   .distinct()
   .forEach(System.out::println);
}

1.2.2. 排序
sorted(Comparable)-自然排序

// sorted(Comparable)-自然排序
public void test1() {
  List<String> list = Arrays.asList("cc",
"aa", "bb", "ee", "dd");
  list.stream()
   .sorted()
   .forEach(System.out::println);
}

sorted(Comparator)-定制排序

// sorted(Comparator)-定制排序
// 需求：按年龄排序，年龄一样按姓名排序
public void test2() {
  emps.stream()
   .sorted((e1, e2) -> {
    
 if(e1.getAge().equals(e2.getAge())) {
        return
e1.getName().compareTo(e1.getName());
     }else {
        return
e1.getAge().compareTo(e2.getAge());
     }
   }).forEach(System.out::println);
}

1.3. 终止操作
1.3.1. 查找与匹配

public void test1() {
  // allMatch-检查是否匹配所有元素
  boolean b1 = emps.stream()
   .allMatch((e) ->
e.getStatus().equals(Status.BUSY));
  System.out.println(b1);
  // anyMatch-检查是否至少匹配一个元素
    boolean b2 = emps.stream()
   .anyMatch((e) ->
e.getStatus().equals(Status.BUSY));
  System.out.println(b2);
  // noneMatch-检查是否没有匹配所有元素
  boolean b3 = emps.stream()
   .noneMatch((e) ->
e.getStatus().equals(Status.OTHER));
  System.out.println(b3);
  // findFirst-返回第一个元素
  // 需求：按工资排序，获取第一个员工信息
  Optional<Employee> op1 = emps.stream()
   .sorted((e1, e2) ->
Double.compare(e1.getSalary(),
e2.getSalary()))
   .findFirst();
  System.out.println(op1.get());
  // findAny-返回当前流中的任意元素
  // 需求：找一个空闲状态的员工，添加到开发团队中
  Optional<Employee> op2 =
emps.parallelStream()// 并行流-多条线程进行，谁先
找到就是谁
   .filter((e) ->
e.getStatus().equals(Status.FERR))
   .findAny();
  System.out.println(op2.get());
    // count-返回流中元素的总个数
  Long count = emps.stream().count();
  System.out.println(count);
  // max-返回流中最大值
  // 需求：获取工资最高的员工信息
  Optional<Employee> op3 = emps.stream()
   .max((e1, e2) ->
Double.compare(e1.getSalary(),
e2.getSalary()));
  System.out.println(op3.get());
  // min-返回流中最小值
  // 需求：获取公司中工资最少员工的工资
  Optional<Double> op4 = emps.stream()
   .map(Employee::getSalary)
   .min(Double::compare);
  System.out.println(op4.get());
}

1.4. 收集（了解）
收集-将流转换为其他形式，接收一个Collertor接口的实
现，用于给Stream中元素做汇总的方法

// 需求：获取当前公司所有员工的姓名添加到集合中
// List-把流中所有元素收集到List中
List<String> list = emps.stream()
 .map(Employee::getName)
 .collect(Collectors.toList());
list.forEach(System.out::println);
// Set-把流中所有元素收集到Set中，删除重复项
Set<String> set = emps.stream()
 .map(Employee::getName)
 .collect(Collectors.toSet());
set.forEach(System.out::println);
// Map-把流中所有元素收集到Map中，当出现相同的key时会
抛异常
Map<String, Integer> map = emps.stream()
.collect(Collectors.toMap(Employee::getName,
Employee::getAge));
System.out.println(map);
// 员工总数
Long count = emps.stream()
 .collect(Collectors.counting());
System.out.println(count);
// 工资平均数
Double avg = emps.stream()
.collect(Collectors.averagingDouble(Employee::
getSalary));
System.out.println(avg);
// 工资总和
Double sum = emps.stream()
.collect(Collectors.summingDouble(Employee::ge
tSalary));
System.out.println(sum);
// 工资最大值的员工
Optional<Employee> op = emps.stream()
 .collect(Collectors.maxBy((e1, e2) ->
Double.compare(e1.getSalary(),
e2.getSalary())));
System.out.println(op.get());

注意：
1、Stream自己不会存储元素·
2、Stream不会改变源对象。相反，会返回一个持有结果
的新Stream。
3、Stream操作是延迟执行的，这意味着他们会等到需要
结果的时候才执行。