java8流式操作、stream

原创

程序三两行 2022-10-09 20:19:38 博主文章分类：java项目&资源 ©著作权

©著作权归作者所有：来自51CTO博客作者程序三两行的原创作品，请联系作者获取转载授权，否则将追究法律责任

引言

前面小猿总结了下java8中的新特新---Lambda表达式，不熟悉的小伙伴可以查看，这篇文章会用到lambda部分知识

这里小猿将介绍另一大java8引入的语法特性---Stream（流操作）

要知道什么是流式操作（Stream）操作，首先介绍一些什么是流操作，这里通过一个小小的案例看看流操作

//定义一个entity类Person
public class Person {
  private String name;
  private int age;
  public String getName() {
    return name;
  }
  //这里修改返回类型为Person
  public Person setName(String name) {
    this.name = name;
    return this;
  }
  public int getAge() {
    return age;
  }
       //这里修改返回类型为Person
  public Person setAge(int age) {
    this.age = age;
    return this;
  }
  public Person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
  public Person() {
    
  }
  @Override
  public String toString() {
    return "Person [name=" + name + ", age=" + age + "]";
  }
  
}

关键代码

public class Demo {
  public static void main(String[] args) {
    Person person = new Person();
    person.setName("李四").setAge(16);
  }
}

通过上面代码我们可以分析当设置完姓名李四之后，我们还能接着设置年龄，这种用上一个过程的结果接着做另一件事的操作就是流操作。也就是说流只是一个计算的过程，并不会存储源对象，下面详细看看流式操作。

Stream实现步骤

1.获取数据源

                // 方式一:java8对collection集合的接口扩展,支持创建流
    List<String> list = new ArrayList<>();
    Stream<String> stream = list.stream();// 返回一个顺序流
    Stream<String> stream2 = list.parallelStream();// 返回一个并行流
    // 方式二:通过Arrays静态方法Stream
    Person[] person = new Person[10];
    Stream<Person> stream3 = Arrays.stream(person);
    // 方式三:通过stream的静态方法.of
    Stream<String> stream4 = Stream.of("aa", "bb");
    // 方式四:无限流
    // 使用iterate创建无限流 0, (x)->x+2中0表示种子，可以查看源码
    Stream<Integer> stream5 = Stream.iterate(0, (x) -> x + 2);
    // 使用生成创建无限流，使用generate，比如生成随机数流
    Stream.generate(()->Math.random());

2.对数据进行处理(过滤映射)每一步得到一个流，成为中间操作

// 首创建一个集合流
List<Person> persons = Arrays.asList(
new Person("李四", 12),new Person("张三", 15),
new Person("网二", 18),new Person("王哈", 28),new Person("网二", 18));
Stream<Person> pStream = persons.stream();

筛选与切片

主要API

filter(Predicate p) 接收 Lambda ，从流中排除某些元素。
distinct() 筛选，通过流所生成元素的hashCode() 和 equals() 去除重复元素（需要重写对象得hashcode和equals方法）
limit(long maxSize) 截断流，使其元素不超过给定数量。
skip(long n) 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

//演示filter(Predicate p)和distinct()API,查询年龄大于15，去重的人的信息
pStream.filter((x) -> x.getAge() > 15)
  .distinct()
  .forEach(System.out::println);

结果

Person [name=网二, age=18]
Person [name=王哈, age=28]

映射

主要的API

map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的
DoubleStream。 mapToInt(ToIntFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的
IntStream。 mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的
LongStream。 flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

// 演示map(Function f) 将所有的person年龄+2
pStream.map((p)->p.getAge()+2).forEach(System.out::println);

排序

主要API

sorted() 产生一个新流，其中按自然顺序排序
sorted(Comparator comp) 产生一个新流，其中按比较器顺序排序

//创建一个流
List<String> list = Arrays.asList("aaa","bbb","ccc","dd");
//自然排序
list.stream().sorted().forEach(System.out::println);

// 首创建一个集合流
List<Person> persons = Arrays.asList(
  new Person("李四", 12), new Person("张三", 15), new Person("网二", 18),
        new Person("王哈", 28), new Person("张二", 18));
  persons.stream().sorted((a, b) -> {
    if (a.getAge() == b.getAge()) {
      return a.getName().compareTo(b.getName());
    } else {
      return a.getAge() - b.getAge();
    }
  }).forEach(System.out::println);

3.对流中数据的整合（转成集合数量），对流中的数据做了整合，称为最终操作

主要API

allMatch(Predicate p) 检查是否匹配所有元素
anyMatch(Predicate p) 检查是否至少匹配一个元素
noneMatch(Predicate p) 检查是否没有匹配所有元素
findFirst() 返回第一个元素
findAny() 返回当前流中的任意元素

// 首创建一个集合流
List<Person> persons = Arrays.asList(
new Person("李四", 12), 
new Person("张三", 15), 
new Person("网二", 18),
new Person("王哈", 28),
new Person("张二", 18));
//演示取得第一个流
Optional<Person> pOptional = persons.stream().findFirst();
System.out.println(pOptional.get());//Person [name=李四, age=12]