Java8——Stream流

简介: Stream是数据渠道,用于操作集合、数组等生成的元素序列。

Stream是数据渠道,用于操作集合、数组等生成的元素序列。

Stream操作的三个步骤:

  • 创建Stream
  • 中间操作
  • 终止操作

一、获取stream的四种方式

  1. 通过collection系列集合的stream()parallelStream()获取。
@Test
void test11(){
    List<String> list = new ArrayList<>();
    Stream<String> stringStream = list.stream();
}
  1. 通过Arrays中的静态方法stream()获取数组流。
@Test
void test11(){
    Person[] person = new Person[10];
    Arrays.stream(person);
}
  1. 通过Stream中的静态方法of()
@Test
void test11(){
    Stream<String> stream = Stream.of("a", "b", "c");
}
  1. 创建无限流
/**
 * 迭代
 */
@Test
void test11(){
    Stream<Integer> integerStream = Stream.iterate(0, x -> x + 2);
}
/**
 * 生成
 */
@Test
void test11(){
    Stream.generate(() -> Math.random());
}

二、中间操作

中间操作不会执行任何操作,只有终止操作才会一次性输出全部值,即“惰性求值”。

2.1 筛选与切片

  • filter——接收lamdba,从流中排除某些元素
@Test
void test12(){
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20)
    );
    // 中间操作
    Stream<Person> personStream = personList.stream()
        .filter(e -> e.getAge() > 18);
    // 终止操作
    personStream.forEach(System.out::println);
}
  • limit——截断流,使其元素不超过给定数量
@Test
void test12(){
    
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20)
    );
    personList.stream()
        .limit(1)
        .forEach(System.out::println);
}
  • skip(n)——跳过元素,返回一个扔掉前n个元素的流,若不足n个,则返回一个空流。与limit(n)互补。
@Test
void test12(){
    
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20)
    );
    personList.stream()
        .skip(1)
        .forEach(System.out::println);
}
  • distinct——筛选,通过生成元素的hashCode()equals(),去除重复元素。
@Test
void test12(){
    
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20),
        new Person("Java旅途",20)
    );
    personList.stream()
        .distinct()
        .forEach(System.out::println);
}

注意:使用distinct的时候需要重写实体的hashCode()equals()方法。

2.2 映射

  • map——接收lamdba,将元素转换成其他形式或提取信息。接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
/**
 * 获取personList的所有name
 */
@Test
void test13(){
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20),
        new Person("Java旅途",20)
    );
    personList.stream()
        .map(Person::getName)
        .forEach(System.out::println);
}
  • flatMap——接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流生成一个流。
// 将字符串转换为字符,并将字符放进list返回
static Stream<Character> filterCharcter(String string){

    List<Character> list = new ArrayList<>();
    for (Character ch : string.toCharArray()){
        list.add(ch);
    }
    return list.stream();
}
@Test
void test13(){
    List<String> list = Arrays.asList("aaa","bbb","ccc");

    list.stream()
        .flatMap(LamdbaApplicationTests::filterCharcter)
        .forEach(System.out::println);
}

2.3 排序

  • sorted()——自然排序(comparable)
  • sorted(comparator com)——定制排序(comparator )
/**
* 定制排序,e1和e2按age排序,age一样按name排
*/
@Test
void test14(){
    List<Person> personList = Arrays.asList(
            new Person("Java旅途",18),
            new Person("Java旅途",20)
    );
    personList.stream()
        .sorted((e1,e2) -> {
            if(e1.getAge() == e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            }else{
                return e1.getAge()+"".compareTo(e2.getAge()+"");
            }
        }).forEach(System.out::println);
}

三、终止操作

3.1 查找与匹配

完善一下Person

@Data
public class Person implements Serializable {
    private static final long serialVersionUID = -7008474395345458049L;

    private String name;
    private int age;
    private Status status;
    
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person(String name, int age, Status status) {
        this.name = name;
        this.age = age;
        this.status = status;
    }
    public enum Status {
        FRER,
        BUSY;
    }
}
  • allMatch——检查是否匹配所有元素
/**
* 是否所有元素都是Fire状态,是返回true
*/
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    boolean b = personList1.stream()
        .allMatch(e -> e.getStatus().equals(Person.Status.FRER));
    System.out.println(b);
}
  • anyMatch——检查是否至少匹配一个元素
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    boolean b = personList1.stream()
        .anyMatch(e -> e.getStatus().equals(Person.Status.FRER));
    System.out.println(b);
}
  • noneMatch——检查是否所有元素都不匹配
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    boolean b = personList1.stream()
        .noneMatch(e -> e.getStatus().equals(Person.Status.FRER));
    System.out.println(b);
}
  • findFirst——返回第一个元素
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    Optional b = personList1.stream()
        .findFirst();
    System.out.println(b.get());
}
  • findAny——返回当前流中的任意元素
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    Optional b = personList1.stream()
        .findAny();
    System.out.println(b.get());
}
  • count——返回流中元素的总数
  • max——返回流中最大值
  • min——返回流中最小值

3.2 规约

  • reduce(T identity, BinaryOperator)/reduce(BinaryOperator)——可以将流中元素反复结合起来,得到一个值。
/**
  * reduce 第一个参数是起始值
  */
@Test
void test16(){
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    Integer sum = list.stream()
                      .reduce(0,(x,y) -> x+y);
    System.out.println(sum);
    
    Optional<Integer> reduce = list.stream()
                                   .reduce((x, y) -> x + y);
    System.out.println(reduce.get());
}

3.3 收集

  • collect——将流转化为其他形式。接收一个Collector接口的实现。用于给Stream中元素做汇总的方法。
/**
* 取出名字放在一个list中
*/
@Test
void test16(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    List<String> collect = personList1.stream()
        .map(Person::getName)
        .collect(Collectors.toList());
    collect.forEach(System.out::println);
}

Optional常用方法

Optional类是一个容器类,代表一个值存在或不存在,原来用null表示一个值不存在,现在Optional可以更好的表达这个概念。并且可以避免空指针异常。

  1. Optional.of(T t) ——创建一个Optional实例
  2. Optional.empty()——创建一个空的optional实例
  3. Optional.ofNullable(T t)——若t不为null,创建optional实例,否则创建空实例
  4. isPresent()——判断是否包含值
  5. orElse(T t)——如果调用对象包含值,返回该值,否则返回 t
  6. orElseGet(Supplier s)——如果调用对象包含值,返回该值,否则返回 s 获取的值
  7. map(Function f)——如果有值对其处理,并返回处理后的Optional,否则返回Optional.empty()
  8. flatMap(Function mapper)——与map类似,要求返回值必须是Optional
目录
相关文章
|
8天前
|
存储 Java API
Java Stream API:现代数据处理之道
Java Stream API:现代数据处理之道
173 92
|
8天前
|
存储 Java API
Java Stream API:现代数据处理之道
Java Stream API:现代数据处理之道
128 68
|
2月前
|
Oracle Java 关系型数据库
掌握Java Stream API:高效集合处理的利器
掌握Java Stream API:高效集合处理的利器
328 80
|
2月前
|
安全 Java API
Java 8 Stream API:高效集合处理的利器
Java 8 Stream API:高效集合处理的利器
217 83
|
3月前
|
SQL JSON 安全
Java 8 + 中 Lambda 表达式与 Stream API 的应用解析
摘要:本文介绍了Java 8+核心新特性,包括Lambda表达式与Stream API的集合操作(如过滤统计)、函数式接口的自定义实现、Optional类的空值安全处理、接口默认方法与静态方法的扩展能力,以及Java 9模块化系统的组件管理。每个特性均配有典型应用场景和代码示例,如使用Stream统计字符串长度、Optional处理Map取值、模块化项目的依赖声明等,帮助开发者掌握现代Java的高效编程范式。(150字)
55 1
|
3月前
|
存储 Java 大数据
Java代码优化:for、foreach、stream使用法则与性能比较
总结起来,for、foreach和stream各自都有其适用性和优势,在面对不同的情况时,有意识的选择更合适的工具,能帮助我们更好的解决问题。记住,没有哪个方法在所有情况下都是最优的,关键在于理解它们各自的特性和适用场景。
331 23
|
2月前
|
SQL 人工智能 Rust
Java 开发中Stream的toMap与Map 使用技巧
本文深入解析了 Java 中 `toMap()` 方法的三大问题:重复键抛出异常、`null` 值带来的风险以及并行流中的性能陷阱,并提供了多种替代方案,如使用 `groupingBy`、`toConcurrentMap` 及自定义收集器,帮助开发者更安全高效地进行数据处理。
128 0
|
9月前
|
存储 Java 数据挖掘
Java 8 新特性之 Stream API:函数式编程风格的数据处理范式
Java 8 引入的 Stream API 提供了一种新的数据处理方式,支持函数式编程风格,能够高效、简洁地处理集合数据,实现过滤、映射、聚合等操作。
258 6
|
9月前
|
Java API 开发者
Java中的Lambda表达式与Stream API的协同作用
在本文中,我们将探讨Java 8引入的Lambda表达式和Stream API如何改变我们处理集合和数组的方式。Lambda表达式提供了一种简洁的方法来表达代码块,而Stream API则允许我们对数据流进行高级操作,如过滤、映射和归约。通过结合使用这两种技术,我们可以以声明式的方式编写更简洁、更易于理解和维护的代码。本文将介绍Lambda表达式和Stream API的基本概念,并通过示例展示它们在实际项目中的应用。
|
11月前
|
Java 流计算
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具!
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具!
141 1
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具!

热门文章

最新文章