Java8 Stream流方法

流是Java API的新成员,它允许以声明性方式处理数据集合(通过查询语句来表达,而不是临时编写一个实现)。就现在来说,可以把它们看成遍历数据集的高级迭代器。此外,流还可以透明地并行处理,无需写任何多线程代码了!

流的使用一般包括三件事:

•一个数据源(如集合)来执行一个查询;

•一个中间操作链,形成一条流的流水线;

•一个终端操作,执行流水线,并能生成结果。


流方法


含义


示例


filter


(中间操作)该操作会接受一个谓词(一个返回boolean的函数)作为参数,并返回一个包括所有符合谓词的元素的流。


List<Dish> vegetarianMenu = menu.stream()

.filter(Dish::isVegetarian)

.collect(toList());

System.out.println(vegetarianMenu);


distinct


(中间操作)返回一个元素各异(根据流所生成元素的hashCode和equals方法实现)的流。


List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);

numbers.stream()

.filter(i -> i % 2 == 0)

.distinct()

.forEach(System.out::println);


limit


(中间操作)会返回一个不超过给定长度的流。


List<Dish> dishes = menu.stream()

.filter(d -> d.getCalories() > 300)

.limit(3)

.collect(toList());

System.out.println(dishes);


skip


(中间操作)返回一个扔掉了前n个元素的流。


List<Dish> dishes = menu.stream()

.filter(d -> d.getCalories() > 300)

.skip(2)

.collect(toList());

System.out.println(dishes);


map


(中间操作)接受一个函数作为参数。这个函数会被应用到每个元素上,并将其映射成一个新的元素(使用映射一词,是因为它和转换类似,但其中的细微差别在于它是“创建一个新版本”而不是去“修改”)。


List<String> dishNames = menu.stream()

.map(Dish::getName)

.collect(toList());

System.out.println(dishNames);


flatMap


(中间操作)使用flatMap方法的效果是,各个数组并不是分别映射成一个流,而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来,即扁平化为一个流。


List<String> words = Arrays.asList("Goodbye", "World");

List<String> uniqueCharacters = words.stream()

.map(w -> w.split(""))

.flatMap(Arrays::stream)

.distinct()

.collect(Collectors.toList());

System.out.println(uniqueCharacters);


sorted


(中间操作)返回排序后的流


List<String> traderStr = menu.stream()

.map(transaction -> transaction.getName())

.sorted()

.collect(toList());

System.out.println(traderStr);


anyMatch


(终端操作)可以回答“流中是否有一个元素能匹配给定的谓词”。


if (menu.stream().anyMatch(Dish::isVegetarian)) {

System.out.println("The menu is (somewhat) vegetarian friendly!!");

}


allMatch


(终端操作)会看看流中的元素是否都能匹配给定的谓词。


boolean isHealthy = menu.stream()

.allMatch(d -> d.getCalories() < 1000);

System.out.println(isHealthy);


noneMatch


(终端操作)可以确保流中没有任何元素与给定的谓词匹配。


boolean isHealthy = menu.stream()

.noneMatch(d -> d.getCalories() >= 1000);

System.out.println(isHealthy);


findAny


(终端操作)将返回当前流中的任意元素。


Optional<Dish> dish = menu.stream()

.filter(Dish::isVegetarian)

.findAny();

System.out.println(dish);


findFirst


(终端操作)有些流有一个出现顺序(encounter order)来指定流中项目出现的逻辑顺序(比如由List或排序好的数据列生成的流)。对于这种流,可能想要找到第一个元素。


List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);

Optional<Integer> firstSquareDivisibleByThree = someNumbers.stream()

.map(x -> x * x)

.filter(x -> x % 3 == 0)

.findFirst();

System.out.println(firstSquareDivisibleByThree);


forEach


(终端操作)遍历流


List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);

numbers.stream()

.filter(i -> i % 2 == 0)

.distinct()

.forEach(System.out::println);


collect


(终端操作)收集器


List<String> traderStr = menu.stream()

.map(transaction -> transaction.getName())

.sorted()

.collect(toList());


reduce


(终端操作)归约reduce接受两个参数:

•一个初始值,这里是0;

•一个BinaryOperator<T>来将两个元素结合起来产生一个新值,这里我们用的是lambda (a, b) -> a + b。


List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);

int sum = numbers.stream().reduce(0, (a, b) -> a + b);

System.out.println(sum);


count


(终端操作)返回此流中元素的计数。


long evenNumbers = IntStream.rangeClosed(1, 100)

.filter(n -> n % 2 == 0)

.count();

System.out.println(evenNumbers);

•可以使用filter、distinct、skip和limit对流做筛选和切片。

•可以使用map和flatMap提取或转换流中的元素。

•可以使用findFirst和findAny方法查找流中的元素。可以用allMatch、noneMatch和anyMatch方法让流匹配给定的谓词。

•这些方法都利用了短路:找到结果就立即停止计算;没有必要处理整个流。

•可以利用reduce方法将流中所有的元素迭代合并成一个结果,例如求和或查找最大元素。

•filter和map等操作是无状态的,它们并不存储任何状态。reduce等操作要存储状态才能计算出一个值。sorted和distinct等操作也要存储状态,因为它们需要把流中的所有元素缓存起来才能返回一个新的流。这种操作称为有状态操作。

•流有三种基本的原始类型特化:IntStream、DoubleStream和LongStream。它们的操作也有相应的特化。

•流不仅可以从集合创建,也可从值、数组、文件以及iterate与generate等特定方法创建。

•无限流是没有固定大小的流。

附:示例中用到的类

package lambdasinaction.chap4;
import java.util.*;

public class Dish {

    private final String name;
    private final boolean vegetarian;
    private final int calories;
    private final Type type;

    public Dish(String name, boolean vegetarian, int calories, Type type) {
        this.name = name;
        this.vegetarian = vegetarian;
        this.calories = calories;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public boolean isVegetarian() {
        return vegetarian;
    }

    public int getCalories() {
        return calories;
    }

    public Type getType() {
        return type;
    }

    public enum Type { MEAT, FISH, OTHER }

    @Override
    public String toString() {
        return name;
    }

    public static final List<Dish> menu =
            Arrays.asList( new Dish("pork", false, 800, Dish.Type.MEAT),
                           new Dish("beef", false, 700, Dish.Type.MEAT),
                           new Dish("chicken", false, 400, Dish.Type.MEAT),
                           new Dish("french fries", true, 530, Dish.Type.OTHER),
                           new Dish("rice", true, 350, Dish.Type.OTHER),
                           new Dish("season fruit", true, 120, Dish.Type.OTHER),
                           new Dish("pizza", true, 550, Dish.Type.OTHER),
                           new Dish("prawns", false, 400, Dish.Type.FISH),
                           new Dish("salmon", false, 450, Dish.Type.FISH));
}

参考:java8实战

原文地址:https://www.cnblogs.com/ooo0/p/11439432.html

时间: 2024-10-09 06:03:08

Java8 Stream流方法的相关文章

Java8 Stream流

Java8 Stream流 Java8关于map和flatMap的代码片段思考 Java8初体验(二)Stream语法详解 distinct() /* 返回一个流包含不同的元素(根据equals方法判断,null值并不会报空指针异常,会保留一个null). 对于有序的流保证稳定性,保留最先出现的元素,对于无序的流不保证稳定性. */ /** * Returns a stream consisting of the distinct elements (according to * {@link

【转】Java8 Stream 流详解

  当我第一次阅读 Java8 中的 Stream API 时,说实话,我非常困惑,因为它的名字听起来与 Java I0 框架中的 InputStream 和 OutputStream 非常类似.但是实际上,它们完全是不同的东西. Java8 Stream 使用的是函数式编程模式,如同它的名字一样,它可以被用来对集合进行链状流式的操作. 本文就将带着你如何使用 Java 8 不同类型的 Stream 操作.同时您还将了解流的处理顺序,以及不同顺序的流操作是如何影响运行时性能的. 我们还将学习终端

java8 stream流操作

Stream 在对流进行处理时,不同的流操作以级联的方式形成处理流水线.一个流水线由一个源(source),0 到多个中间操作(intermediate operation)和一个终结操作(terminal operation)完成. 源:源是流中元素的来源.Java 提供了很多内置的源,包括数组.集合.生成函数和 I/O 通道等. 中间操作:中间操作在一个流上进行操作,返回结果是一个新的流.这些操作是延迟执行的. 终结操作:终结操作遍历流来产生一个结果或是副作用.在一个流上执行终结操作之后,该

关于Java8 Stream流的利与弊 Java初学者,大神勿喷

1:第一个队伍只要名字为3个字成员的姓名,存储到新集合 2:第一个队伍筛选之后只要前3人:存储到一个新集合 3:第2个队伍只要姓张的成员姓名:存储到一个新集合 4:第2个队伍不要前2人,存储到一个新集合 5:将2个队伍合并到一个队伍,存储到一个新集合 6:根据姓名创建Person对象,存储到一个新集合 //使用普通方法进行筛选 前面加了一个时间类 import java.util.ArrayList;public class Demo08List { public static void mai

Java8 Stream流使用及其基本原理

Stream流,是对集合对象操作的增强 基本使用 比如有一个Person类的集合:List<Person> personList,可以通过stream()对集合中的元素进行操作, 下面的操作流程可以归纳为 过滤-映射-收集. List<Integer> personIdList = personList.stream() //选出年龄大于20的Person对象 .filter(person -> person.getAge() > 20) //将Person对象映射成为

Java8 Stream流API常用操作

Java版本现在已经发布到JDK13了,目前公司还是用的JDK8,还是有必要了解一些JDK8的新特性的,例如优雅判空的Optional类,操作集合的Stream流,函数式编程等等;这里就按操作例举一些常用的Stream流操作; Stream流简介 A sequence of elements supporting sequential and parallel aggregate operations. Stream流是一个来自数据源的元素队列并支持聚合操作 Stream流中常用方法的分类 1.

Java8 Stream 流使用场景和常用操作

JAVA8内置的函数式编程接口应用场景和方式 pojo类对象和默认创建list的方法 import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.util.ArrayList; import java.util.List; @Data @AllArgsConstructor @NoArgsConstructor public class DotaHero {

java8 stream流操作的flatMap(流的扁平化)

https://mp.weixin.qq.com/s/7Fqb6tAucrl8UmyiY78AXg https://blog.csdn.net/Mark_Chao/article/details/80810030 原文地址:https://www.cnblogs.com/alter888/p/11966114.html

乐字节-Java8新特性-接口默认方法之Stream流(下)

接上一篇:<Java8新特性之stream>,下面继续接着讲Stream 5.流的中间操作 常见的流的中间操作,归为以下三大类:筛选和切片流操作.元素映射操作.元素排序操作: 操作 描述 筛选和切片 filter(T -> boolean):保留 boolean 为 true 的元素 limit(long n):返回前 n 个元素 skip(long n):去除前 n 个元素 distinct():去除重复元素,这个方法是通过类的 equals 方法来判断两个元素是否相等的 映射 map