首页 > > 程序设计 > Java技术 >

JAVA-基础（Stream流）

2019-08-16 09:33:34来源：博客园阅读 ()

JAVA-基础（Stream流）

说起stream流大家的第一反应是io，但是实际上谁规定流一定是存在io包里呢？在java8中得益于Lambda表达式的函数式编程，引入了一个全新的概念，stream。

1.优势？

在java8之前我们遍历集合大概就是增强for循环，如果我们想在这个集合里增加一些添加来搜索集合的一些东西，我们会发现代码会变得非常杂乱无章，但是我们现在用stream就会很优雅的解决这个问题。

代码：

首先筛选所有姓茂的人；
然后筛选名字有三个字的人；
最后进行对结果进行打印输出。

 1 package cn.fan;
 2 ?
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 ?
 6 public class Stream1 {
 7     public static void main(String[] args) {
 8         //第一条件：筛选姓茂的
 9         //第二条件：筛选名字三个字的
10         //再进行打印
11         List<String> list = new ArrayList<>();
12         list.add("茂小喵");
13         list.add("罗三炮");
14         list.add("阿龟哥");
15         list.add("范小饭");
16         List<String> maoList = new ArrayList<>();
17         for (String name : list) {
18             if (name.startsWith("茂")) {
19                 maoList.add(name);
20             }
21         }
22 ?
23         List<String> shortList = new ArrayList<>();
24         for (String name : maoList) {
25             if (name.length() == 3) {
26                 shortList.add(name);
27             }
28         }
29 ?
30         for (String name : shortList) {
31             System.out.println(name);
32         }
33 ?
34     }
35 }

View Code

那么现在有一种更加优雅的做法：

 1 package cn.fan;
 2 ?
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 ?
 6 public class Stream2 {
 7     public static void main(String[] args) {
 8         List<String> list = new ArrayList<>();
 9         list.add("茂小喵");
10         list.add("罗三炮");
11         list.add("阿龟哥");
12         list.add("范小饭");
13 ?
14         list.stream()
15                 .filter(s->s.startsWith("茂"))
16                 .filter(s->s.length()==3)
17                 .forEach(System.out::println);
18     }
19 }

View Code

Stream（流）是一个来自数据源的元素队列。元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。数据源流的来源。可以是集合，数组等。

“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。

2.获取stream的两种方法？

default Stream<E> stream()

static <T> Stream<T> of(T... values)

 1 package com.itheima.demo02.Stream;
 2 ?
 3 import java.util.*;
 4 import java.util.stream.Stream;
 5 ?
 6 /*
 7     java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）
 8     获取一个流非常简单，有以下几种常用的方式：
 9         - 所有的Collection集合都可以通过stream默认方法获取流；
10             default Stream<E> stream()
11         - Stream接口的静态方法of可以获取数组对应的流。
12             static <T> Stream<T> of(T... values)
13             参数是一个可变参数,那么我们就可以传递一个数组
14  */
15 public class Demo01GetStream {
16     public static void main(String[] args) {
17         //把集合转换为Stream流
18         List<String> list = new ArrayList<>();
19         Stream<String> stream1 = list.stream();  Set<String> set = new HashSet<>();
20     Stream<String> stream2 = set.stream();
21 ?
22     Map<String,String> map = new HashMap<>();
23     //获取键,存储到一个Set集合中
24     Set<String> keySet = map.keySet();
25     Stream<String> stream3 = keySet.stream();
26 ?
27     //获取值,存储到一个Collection集合中
28     Collection<String> values = map.values();
29     Stream<String> stream4 = values.stream();
30 ?
31     //获取键值对(键与值的映射关系 entrySet)
32     Set<Map.Entry<String, String>> entries = map.entrySet();
33     Stream<Map.Entry<String, String>> stream5 = entries.stream();
34 ?
35     //把数组转换为Stream流
36     Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
37     //可变参数可以传递数组
38     Integer[] arr = {1,2,3,4,5};
39     Stream<Integer> stream7 = Stream.of(arr);
40     String[] arr2 = {"a","bb","ccc"};
41     Stream<String> stream8 = Stream.of(arr2);
42 }
43 }

View Code

3.stream流只能使用一次？为什么？

首先我们要知道，stream流属于管道流，只能被消费一次，当第一个stream流调用完毕方法，数据就会流向下一个stream流，所以第一个stream流就没数据了，关闭了。

4.映射，将一个stream流的数据转换为另一种stream流？

如果我们需要将流中的元素映射到一个流中，我们可以使用map方法

代码：

 1 package cn.fan;
 2 ?
 3 import java.util.stream.Stream;
 4 ?
 5 /*
 6     Stream流中的常用方法_map:用于类型转换
 7     如果需要将流中的元素映射到另一个流中，可以使用map方法.
 8     <R> Stream<R> map(Function<? super T, ? extends R> mapper);
 9     该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
10     Function中的抽象方法:
11         R apply(T t);
12  */
13 public class Stream_map {
14     public static void main(String[] args) {
15         //获取一个String类型的Stream流
16         Stream<String> stream = Stream.of("1", "2", "3", "4");
17         //使用map方法,把字符串类型的整数,转换(映射)为Integer类型的整数
18         Stream<Integer> stream2 = stream.map((String s)->{
19             return Integer.parseInt(s);
20         });
21         //遍历Stream2流
22         stream2.forEach(i-> System.out.println(i));
23     }
24 }

View Code

5.终结方法，将一个stream流的数据count？

 1 package cn.fan;
 2 ?
 3 import java.util.stream.Stream;
 4 ?
 5 ?
 6 public class StreamCount {
 7     public static void main(String[] args) {
 8         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
 9         Stream<String> result = original.filter(s -> s.startsWith("张"));
10         System.out.println(result.count()); // 2
11     }
12 ?
13 }

View Code

6.取用前几个：limit？

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：

 1 package cn.fan;
 2 import java.util.stream.Stream;
 3 ?
 4 public class StreamLimit {
 5     public static void main(String[] args) {
 6         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
 7         Stream<String> result = original.limit(2);
 8         System.out.println(result.count()); // 2
 9     }
10 }

View Code

7.跳过前几个：skip？

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream skip(long n);

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

 1 package cn.fan;
 2 ?
 3 import java.util.stream.Stream;
 4 ?
 5 public class StreamSkip {
 6     public static void main(String[] args) {
 7         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
 8         Stream<String> result = original.skip(2);
 9         System.out.println(result.count()); // 1
10     }
11 ?
12 }

View Code

8.组合：concat？

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static Stream concat(Stream a, Stream b)

备注：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

 1 package cn.fan;
 2 ?
 3 import java.util.stream.Stream;
 4 ?
 5 public class StreamConcat {
 6     public static void main(String[] args) {
 7         Stream<String> streamA = Stream.of("张无忌");
 8         Stream<String> streamB = Stream.of("张翠山");
 9         Stream<String> result = Stream.concat(streamA, streamB);
10     }
11 }