动力节点旗下在线教育品牌  |  咨询热线:400-8080-105 学Java全栈,上蛙课网
首页 > 文章

Java 中的stream流实际操作

06-30 17:45 265浏览
举报 T字号
  • 大字
  • 中字
  • 小字

首先,我们来明确一下java中流的概念:流是代表任何有能力产出数据的数据源对象或者是有能力接受数据的接收端对象。它的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。 我们今天就来单独聊一聊java中的stream流着重讲一下stream流实际操作。

Stream流不是一种数据结构,不保存数据,它只是在原数据集上定义了一组操作。这些操作是惰性的,即每当访问到流中的一个元素,才会在此元素上执行这一系列操作。stream是从起源(source)到接收的(sink)的有序数据。Stream 就好像一个高级的迭代器,但只能遍历一次,就好像一江春水向东流;在流的过程中,对流中的元素执行一些操作,比如“过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等。Stream不保存数据,故每个Stream流只能使用一次。

Java的IO模型设计非常优秀,它使用Decorator(装饰者)模式,按功能划分Stream,您可以动态装配这些Stream,以便获得您需要的功能。例如,您需要一个具有缓冲的文件输入流,则应当组合使用FileInputStream和BufferedInputStream。关于应用在Stream流上的操作,可以分成两种:Intermediate(中间操作)和Terminal(终止操作)。中间操作的返回结果都是Stream,故可以多个中间操作叠加;终止操作用于返回我们最终需要的数据,只能有一个终止操作。

举个例子:

List list = new ArrayList<>();

list.add("北京");

list.add("中国");

list.add("世界");

list.add("世界");

long count = list.stream().distinct().count();

System.out.println(count);

distinct() 方法是一个中间操作(去重),它会返回一个新的流(没有共同元素)。

Stream distinct();

count() 方法是一个终端操作,返回流中的元素个数。

long count();

中间操作不会立即执行,只有等到终端操作的时候,流才开始真正地遍历,用于映射、过滤等。通俗点说,就是一次遍历执行多个操作,性能就大大提高了。

使用Stream流,可以清楚地知道我们要对一个数据集做何种操作,可读性强。而且可以很轻松地获取并行化Stream流,不用自己编写多线程代码,可以让我们更加专注于业务逻辑。

下面我们来具体介绍stream流的一些实操:

一、流的创建:

如果是数组的话,可以使用 Arrays.stream() 或者 Stream.of() 创建流;如果是集合的话,可以直接使用 stream() 方法创建流,因为该方法已经添加到 Collection 接口中。

public class CreateStreamDemo {

    public static void main(String[] args) {

        String[] arr = new String[]{"1", "2", "3"};

        Stream stream = Arrays.stream(arr);

        stream = Stream.of("1", "2", "3");

        List list = new ArrayList<>();

        list.add("1");

        list.add("2");

        list.add("3");

        stream = list.stream();

    }

}

查看 Stream 源码的话,你会发现 of() 方法内部其实调用了 Arrays.stream() 方法。

public static Stream of(T... values) {

    return Arrays.stream(values);

}

另外,集合还可以调用 parallelStream() 方法创建并发流,默认使用的是 ForkJoinPool.commonPool()线程池。

 

List aList = new ArrayList<>();

Stream parallelStream = aList.parallelStream();

二、操作流

Stream 类提供了很多有用的操作流的方法,我们着重介绍一些出场率高的。

1)过滤

通过 filter() 方法可以从流中筛选出我们想要的元素。

public class FilterStreamDemo {

    public static void main(String[] args) {

        List list = new ArrayList<>();

        list.add("java");

        list.add("C");

        list.add("C++");

        list.add("phython");

        Stream stream = list.stream().filter(element -> element.contains("j"));

        stream.forEach(System.out::println);

    }

}

filter() 方法接收的是一个 Predicate(Java 8 新增的一个函数式接口,接受一个输入参数返回一个布尔值结果)类型的参数,因此,我们可以直接将一个 Lambda 表达式传递给该方法,比如说 element -> element.contains("j") 就是筛选出带有“j”的字符串。

 

forEach() 方法接收的是一个 Consumer(Java 8 新增的一个函数式接口,接受一个输入参数并且无返回的操作)类型的参数,类名 :: 方法名是 Java 8 引入的新语法,System.out 返回 PrintStream 类,println 方法如我们所知是打印的。

stream.forEach(System.out::println); 相当于在 for 循环中打印,类似于下面的代码:

for (String s : strs) {

    System.out.println(s);

}

很明显,一行代码看起来更简洁一些。来看一下程序的输出结果:Java

2)映射

如果想通过某种操作把一个流中的元素转化成新的流中的元素,可以使用 map() 方法。

public class MapStreamDemo {

    public static void main(String[] args) {

        List list = new ArrayList<>();

        list.add("java");

        list.add("C");

        list.add("C++");

        list.add("phython");

        Stream stream = list.stream().map(String::length);

        stream.forEach(System.out::println);

    }

}

map() 方法接收的是一个 Function(Java 8 新增的一个函数式接口,接受一个输入参数 T,返回一个结果 R)类型的参数,此时参数 为 String 类的 length 方法,也就是把 Stream 的流转成一个 Stream 的流。

程序输出的结果如下所示:

3

3

2

3

3)匹配

Stream 类提供了三个方法可供进行元素匹配,它们分别是:

anyMatch(),只要有一个元素匹配传入的条件,就返回 true。

allMatch(),只有有一个元素不匹配传入的条件,就返回 false;如果全部匹配,则返回 true。

noneMatch(),只要有一个元素匹配传入的条件,就返回 false;如果全部匹配,则返回 true。

public class MatchStreamDemo {

    public static void main(String[] args) {

        List list = new ArrayList<>();

        list.add("java");

        list.add("C");

        list.add("C++");

        list.add("phython");

        boolean  anyMatchFlag = list.stream().anyMatch(element -> element.contains("j"));

        boolean  allMatchFlag = list.stream().allMatch(element -> element.length() < 10);

        boolean  noneMatchFlag = list.stream().noneMatch(element -> element.endsWith("b"));

        System.out.println(anyMatchFlag);

        System.out.println(allMatchFlag);

        System.out.println(noneMatchFlag);

    }

}

因为“java”以“j”字母开头,所以 anyMatchFlag 应该为 true;因为“java”、“C”、“C++”、“phython”的字符串长度都小于 10,所以 allMatchFlag 为 true;因为 4 个字符串结尾都不是“b”,所以 noneMatchFlag 为 true。

程序输出的结果如下所示:

true

true

true

4)组合

reduce() 方法的主要作用是把 Stream 中的元素组合起来,它有两种用法:

Optional reduce(BinaryOperator accumulator)

没有起始值,只有一个参数,就是运算规则,此时返回 Optional。

T reduce(T identity, BinaryOperator accumulator)

有起始值,有运算规则,两个参数,此时返回的类型和起始值类型一致。

来看下面这个例子。

public class ReduceStreamDemo {

    public static void main(String[] args) {

        Integer[] ints = {0, 1, 2, 3};

        List list = Arrays.asList(ints);

        Optional optional = list.stream().reduce((a, b) -> a + b);

        Optional optional1 = list.stream().reduce(Integer::sum);

        System.out.println(optional.orElse(0));

        System.out.println(optional1.orElse(0));

        int reduce = list.stream().reduce(6, (a, b) -> a + b);

        System.out.println(reduce);

        int reduce1 = list.stream().reduce(6, Integer::sum);

        System.out.println(reduce1);

    }

}

运算规则可以是 Lambda 表达式(比如 (a, b) -> a + b),也可以是类名::方法名(比如 Integer::sum)。

程序运行的结果如下所示:

6

6

12

12

0、1、2、3 在没有起始值相加的时候结果为 6;有起始值 6 的时候结果为 12。

三、转换流

既然可以把集合或者数组转成流,那么也应该有对应的方法,将流转换回去——collect() 方法就满足了这种需求。

public class CollectStreamDemo {

    public static void main(String[] args) {

        List list = new ArrayList<>();

        list.add("java");

        list.add("C");

        list.add("C++");

        list.add("phython");

        String[] strArray = list.stream().toArray(String[]::new);

        System.out.println(Arrays.toString(strArray));

 

        List list1 = list.stream().map(String::length).collect(Collectors.toList());

        List list2 = list.stream().collect(Collectors.toCollection(ArrayList::new));

        System.out.println(list1);

        System.out.println(list2);

        String str = list.stream().collect(Collectors.joining(", ")).toString();

        System.out.println(str);

    }

}

toArray() 方法可以将流转换成数组,你可能比较好奇的是 String[]::new,它是什么东东呢?来看一下 toArray() 方法的源码。

A[] toArray(IntFunction generator);

 

也就是说 String[]::new 是一个 IntFunction,一个可以产生所需的新数组的函数,可以通过反编译字节码看看它到底是什么:

String[] strArray = (String[])list.stream().toArray((x$0) -> {

    return new String[x$0];

});

System.out.println(Arrays.toString(strArray));

也就是相当于返回了一个指定长度的字符串数组。

当我们需要把一个集合按照某种规则转成另外一个集合的时候,就可以配套使用 map() 方法和 collect() 方法。

List list1 = list.stream().map(String::length).collect(Collectors.toList());

通过 stream() 方法创建集合的流后,再通过 map(String:length) 将其映射为字符串长度的一个新流,最后通过 collect() 方法将其转换成新的集合。

Collectors 是一个收集器的工具类,内置了一系列收集器实现,比如说 toList() 方法将元素收集到一个新的 java.util.List 中;比如说 toCollection() 方法将元素收集到一个新的 java.util.ArrayList 中;比如说 joining() 方法将元素收集到一个可以用分隔符指定的字符串中。

来看一下程序的输出结果:

[java, C, C++, phython]

[3, 3, 2, 3]

[java, C, C++, phython]

java, C, C++, phython

    小伙伴们,看完了本文是不是觉得stream流的功能很强大呢,让我们一起来学习并掌握stream流的相关知识吧。当然,想要彻底掌握stream流在学好理论的同时还需要更多的实践。“学而不思则罔,思而不学则殆。”我们在不断学习新知识的同时一定要记得多思考哦,举一反三方能学有学成。

0人推荐
共同学习,写下你的评论
0条评论
十年
程序员十年

13篇文章贡献72369字

作者相关文章更多>

推荐相关文章更多>

Java数据结构

HelloWorld10-31 08:24

浅谈MySQL中SQL优化的常用方法

军哥08-12 23:29

五分钟读懂UML类图

江湖人称小李白12-10 10:41

MyBatis开发框架的四大核心

IT逐梦者08-17 21:43

一次搞定continue,break和return

HelloWorld11-06 11:19

发评论

举报

0/150

取消