Java 之 Stream 流
Stream流
在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端 java
1、传统遍历
一、传统集合的多步遍历代码
几乎全部的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操做。而当咱们须要对集合中的元素进行操做的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。算法
例如：编程
1 import java.util.ArrayList; 2 import java.util.List; 3 4 public class DemoForEach { 5 public static void main(String[] args) { 6 List<String> list = new ArrayList<>(); 7 list.add("张无忌"); 8 list.add("周芷若"); 9 list.add("赵敏"); 10 list.add("张强"); 11 list.add("张三丰"); 12 for (String name : list) { 13 System.out.println(name); 14 } 15 } 16 }
二、循环遍历的弊端
Java 8的Lambda让咱们能够更加专一于作什么（What），而不是怎么作（How），这点此前已经结合内部类进行了对比说明。如今，咱们仔细体会一下上例代码，能够发现 数组
-
-
- for循环的语法就是“怎么作”；
- for循环的循环体才是“作什么”
- for循环的语法就是“怎么作”；
-
为何使用循环？由于要进行遍历。但循环是遍历的惟一方式吗？遍历是指每个元素逐一进行处理，而并非从第一个到最后一个顺次处理的循环。前者是目的，后者是方式。 数据结构
试想一下，若是但愿对集合中的元素进行筛选过滤：app
① 将集合A根据条件一过滤为子集B；ide
② 而后再根据条件二过滤为子集C；函数式编程
Java8 以前的作法：函数
1 import java.util.ArrayList; 2 import java.util.List; 3 public class DemoNormalFilter { 4 public static void main(String[] args) { 5 List<String> list = new ArrayList<>(); 6 list.add("张无忌"); 7 list.add("周芷若"); 8 list.add("赵敏"); 9 list.add("张强"); 10 list.add("张三丰"); 11 List<String> zhangList = new ArrayList<>(); 12 for (String name : list) { 13 if (name.startsWith("张")) { 14 zhangList.add(name); 15 } 16 } 17 List<String> shortList = new ArrayList<>(); 18 for (String name : zhangList) { 19 if (name.length() == 3) { 20 shortList.add(name); 21 } 22 } 23 for (String name : shortList) { 24 System.out.println(name); 25 } 26 } 27 }
这段代码中含有三个循环，每个做用不一样：
性能
① 首先筛选出全部姓张的人；
② 而后筛选名字有三个字的人；
③ 最后进行对结果进行打印输出。
每当咱们须要对集合中的元素进行操做的时候，老是须要进行循环、循环、再循环。这是理所固然的么？
不是。循环是作事情的方式，而不是目的。另外一方面，使用线性循环就意味着只能遍历一次。若是但愿再次遍历，只能再使用另外一个循环从头开始。
三、Stream 的更优写法
使用Java8的Stream API，代码实现：
1 import java.util.ArrayList; 2 import java.util.List; 3 4 public class DemoStreamFilter { 5 public static void main(String[] args) { 6 List<String> list = new ArrayList<>(); 7 list.add("张无忌"); 8 list.add("周芷若"); 9 list.add("赵敏"); 10 list.add("张强"); 11 list.add("张三丰"); 12 list.stream() 13 .filter(s -> s.startsWith("张")) 14 .filter(s -> s.length() == 3) 15 .forEach(System.out::println); 16 } 17 }
直接阅读代码的字面意思便可完美展现无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。
代码中并无体现使用线性循环或是其余任何算法进行遍历，咱们真正要作的事情内容被更好地体如今代码中。
2、流式思想概述
总体来看，流式思想相似于工厂车间的“生产流水线”。
当须要对多个元素进行操做（特别是多步操做）的时候，考虑到性能及便利性，应该首先拼好一个“模型”步骤方案，而后再按照方案去执行它。
这张图中展现了过滤、映射、跳过、计数等多步操做，这是一种集合元素的处理方案，而方案就是一种“函数模型”。
图中的每个方框都是一个“流”，调用指定的方法，能够从一个流模型转换为另外一个流模型。而最右侧的数字3是最终结果。
这里的 filter 、 map 、 skip 都是在对函数模型进行操做，集合元素并无真正被处理。只有当终结方法 count执行的时候，整个模型才会按照指定策略执行操做。而这得益于Lambda的延迟执行特性 。
注意：“Stream流”实际上是一个集合元素的函数模型，它并非集合，也不是数据结构，其自己并不存储任何元素（或其地址值）。
Stream（流）是一个来自数据源的元素队列：
-
- 元素是特定类型的对象，造成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
- 数据源 流的来源。 能够是集合，数组 等。
和之前的Collection操做不一样， Stream操做还有两个基础的特征：
-
- Pipelining: 中间操做都会返回流对象自己。 这样多个操做能够串联成一个管道， 如同流式风格（fluentstyle）。 这样作能够对操做进行优化， 好比延迟执行(laziness)和短路( short-circuiting)。
- 内部迭代： 之前对集合遍历都是经过Iterator或者加强for的方式, 显式的在集合外部进行迭代， 这叫作外部迭代。 Stream提供了内部迭代的方式，流能够直接调用遍历方法。
当使用一个流的时候，一般包括三个基本步骤：
获取一个数据源（source）→ 数据转换→执行操做获取想要的结果，
每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（能够有屡次转换），这就容许对其操做能够像链条同样排列，变成一个管道。
3、获取流
java.util.stream.Stream<T> 是Java 8新加入的最经常使用的流接口。（这并非一个函数式接口。）
获取一个流很是简单，有如下几种经常使用的方式：
-
- 全部的 Collection 集合均可以经过 stream 默认方法获取流；
- Stream 接口的静态方法 of 能够获取数组对应的流
- 全部的 Collection 集合均可以经过 stream 默认方法获取流；
一、根据 Collection 获取流
java.util.Collection 接口中加入了default方法 stream 用来获取流，因此其全部实现类都可获取流。
Demo：
1 import java.util .*; 2 import java.util.stream.Stream; 3 4 public class DemoGetStream { 5 public static void main(String[] args) { 6 List<String> list = new ArrayList<>(); 7 // ... 8 Stream<String> stream1 = list.stream(); 9 Set<String> set = new HashSet<>(); 10 // ... 11 Stream<String> stream2 = set.stream(); 12 Vector<String> vector = new Vector<>(); 13 // ... 14 Stream<String> stream3 = vector.stream(); 15 } 16 }
二、根据 Map 获取流
java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，因此获取对应的流须要分key、value或entry等状况：
Demo：
1 import java.util.HashMap; 2 import java.util.Map; 3 import java.util.stream.Stream; 4 5 public class DemoGetStream { 6 public static void main(String[] args) { 7 Map<String, String> map = new HashMap<>(); 8 // ... 9 Stream<String> keyStream = map.keySet().stream(); 10 Stream<String> valueStream = map.values().stream(); 11 Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream(); 12 } 13 }
三、根据数组获取流
若是使用的不是集合或映射而是数组，因为数组对象不可能添加默认方法，因此 Stream 接口中提供了静态方法of ，使用很简单：
Demo：
1 import java.util.stream.Stream; 2 3 public class DemoGetStream { 4 public static void main(String[] args) { 5 String[] array = {"张无忌", "张翠山", "张三丰", "张一元"}; 6 Stream<String> stream = Stream.of(array); 7 } 8 }
注意： of 方法的参数实际上是一个可变参数，因此支持数组。
4、经常使用方法
流模型的操做很丰富，这里介绍一些经常使用的API。这些方法能够被分红两种：
-
- 延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，所以支持链式调用。（除了终结方法外，其他方法均为延迟方法。）
- 终结方法：返回值类型再也不是 Stream 接口自身类型的方法，所以再也不支持相似 StringBuilder 那样的链式调用。本小节中，终结方法包括 count 和 forEach 方法。
一、逐一处理：forEach
虽然方法名字叫 forEach ，可是与for循环中的“for-each”昵称不一样。
void forEach(Consumer<? super T> action);
该方法接收一个 Consumer 接口函数，会将每个流元素交给该函数进行处理。
Consumer 接口
java.util.function.Consumer<T>接口是一个消费型接口。 Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
基本使用：
1 import java.util.stream.Stream; 2 public class DemoStreamForEach { 3 public static void main(String[] args) { 4 Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若"); 5 stream.forEach(name‐> System.out.println(name)); 6 } 7 }
二、过滤：filter
能够经过 filter 方法将一个流转换成另外一个子集流。方法签名：
Stream<T> filter(Predicate<? super T> predicate);
该接口接收一个 Predicate 函数式接口参数（能够是一个Lambda或方法引用）做为筛选条件。
Predicate 接口：
boolean test(T t);
该方法将会产生一个boolean值结果，表明指定的条件是否知足。若是结果为true，那么Stream流的 filter 方法将会留用元素；若是结果为false，那么 filter 方法将会舍弃元素。
基本使用：
1 import java.util.stream.Stream; 2 public class DemoStreamFilter { 3 public static void main(String[] args) { 4 Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 5 Stream<String> result = original.filter(s ‐> s.startsWith("张")); 6 } 7 }
在这里经过Lambda表达式来指定了筛选的条件：必须姓张
三、映射：map
若是须要将流中的元素映射到另外一个流中，可使用 map 方法。方法签名：
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
该接口须要一个 Function 函数式接口参数，能够将当前流中的T类型数据转换为另外一种R类型的流。
Function 接口：
R apply(T t);
这能够将一种T类型转换成为R类型，而这种转换的动做，就称为“映射”。
基本使用：
1 import java.util.stream.Stream; 2 public class DemoStreamMap { 3 public static void main(String[] args) { 4 Stream<String> original = Stream.of("10", "12", "18"); 5 Stream<Integer> result = original.map(str‐>Integer.parseInt(str)); 6 } 7 }
这段代码中， map 方法的参数经过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对象）。
四、统计个数：count
正如旧集合 Collection 当中的 size 方法同样，流提供 count 方法来数一数其中的元素个数：
long count();
该方法返回一个long值表明元素个数（再也不像旧集合那样是int值）。
基本使用：
1 import java.util.stream.Stream; 2 public class DemoStreamCount { 3 public static void main(String[] args) { 4 Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 5 Stream<String> result = original.filter(s ‐> s.startsWith("张")); 6 System.out.println(result.count()); // 2 7 } 8 }
五、取用前几个：limit
limit 方法能够对流进行截取，只取用前n个。方法签名
Stream<T> limit(long maxSize);
参数是一个long型，若是集合当前长度大于参数则进行截取；不然不进行操做。
基本使用：
1 import java.util.stream.Stream; 2 public class DemoStreamLimit { 3 public static void main(String[] args) { 4 Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 5 Stream<String> result = original.limit(2); 6 System.out.println(result.count()); // 2 7 } 8 }
六、跳过前几个：skip
若是但愿跳过前几个元素，可使用 skip 方法获取一个截取以后的新流：
Stream<T> skip(long n);
若是流的当前长度大于n，则跳过前n个；不然将会获得一个长度为0的空流。
基本使用：
1 import java.util.stream.Stream; 2 public class DemoStreamSkip { 3 public static void main(String[] args) { 4 Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 5 Stream<String> result = original.skip(2); 6 System.out.println(result.count()); // 1 7 } 8 }
七、组合：concat
若是有两个流，但愿合并成为一个流，那么可使用 Stream 接口的静态方法 concat ：
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
注意：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不一样的。
基本使用：
1 import java.util.stream.Stream; 2 public class DemoStreamConcat { 3 public static void main(String[] args) { 4 Stream<String> streamA = Stream.of("张无忌"); 5 Stream<String> streamB = Stream.of("张翠山"); 6 Stream<String> result = Stream.concat(streamA, streamB); 7 } 8 }
5、案例
题目：如今有两个 ArrayList 集合存储队伍当中的多个成员姓名， 依次进行如下若干操做步骤：
1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。 2. 第一个队伍筛选以后只要前3我的；存储到一个新集合中。 3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。 4. 第二个队伍筛选以后不要前2我的；存储到一个新集合中。 5. 将两个队伍合并为一个队伍；存储到一个新集合中。 6. 根据姓名建立 Person 对象；存储到一个新集合中。 7. 打印整个队伍的Person对象信息。
两个队伍（集合）的代码以下：
1 import java.util.ArrayList; 2 import java.util.List; 3 public class DemoArrayListNames { 4 public static void main(String[] args) { 5 //第一支队伍 6 ArrayList<String> one = new ArrayList<>(); 7 one.add("迪丽热巴"); 8 one.add("宋远桥"); 9 one.add("苏星河"); 10 one.add("石破天"); 11 one.add("石中玉"); 12 one.add("老子"); 13 one.add("庄子"); 14 one.add("洪七公"); 15 //第二支队伍 16 ArrayList<String> two = new ArrayList<>(); 17 two.add("古力娜扎"); 18 two.add("张无忌"); 19 two.add("赵丽颖"); 20 two.add("张三丰"); 21 two.add("尼古拉斯赵四"); 22 two.add("张天爱"); 23 two.add("张二狗"); 24 // .... 25 } 26 }
Person 类的代码为：
1 public class Person { 2 private String name; 3 4 public Person() { 5 } 6 7 public Person(String name) { 8 this.name = name; 9 } 10 11 @Override 12 public String toString() { 13 return "Person{name='" + name + "'}"; 14 } 15 16 public String getName() { 17 return name; 18 } 19 20 public void setName(String name) { 21 this.name = name; 22 } 23 }
方式一：使用传统的for循环（或加强for循环）
代码实现：
1 public class DemoArrayListNames { 2 public static void main(String[] args) { 3 List<String> one = new ArrayList<>(); 4 // ... 5 List<String> two = new ArrayList<>(); 6 // ... 7 8 // 第一个队伍只要名字为3个字的成员姓名； 9 List<String> oneA = new ArrayList<>(); 10 for (String name : one) { 11 if (name.length() == 3) { 12 oneA.add(name); 13 } 14 } 15 16 // 第一个队伍筛选以后只要前3我的； 17 List<String> oneB = new ArrayList<>(); 18 for (int i = 0; i < 3; i++) { 19 oneB.add(oneA.get(i)); 20 } 21 22 // 第二个队伍只要姓张的成员姓名； 23 List<String> twoA = new ArrayList<>(); 24 for (String name : two) { 25 if (name.startsWith("张")) { 26 twoA.add(name); 27 } 28 } 29 30 // 第二个队伍筛选以后不要前2我的； 31 List<String> twoB = new ArrayList<>(); 32 for (int i = 2; i < twoA.size(); i++) { 33 twoB.add(twoA.get(i)); 34 } 35 36 // 将两个队伍合并为一个队伍； 37 List<String> totalNames = new ArrayList<>(); 38 totalNames.addAll(oneB); 39 totalNames.addAll(twoB); 40 // 根据姓名建立Person对象； 41 List<Person> totalPersonList = new ArrayList<>(); 42 for (String name : totalNames) { 43 totalPersonList.add(new Person(name)); 44 } 45 // 打印整个队伍的Person对象信息。 46 for (Person person : totalPersonList) { 47 System.out.println(person); 48 } 49 } 50 }
方式二：使用 Stream 流式处理方式。
代码实现：
1 import java.util.ArrayList; 2 import java.util.List; 3 import java.util.stream.Stream; 4 public class DemoStreamNames { 5 public static void main(String[] args) { 6 List<String> one = new ArrayList<>(); 7 // ... 8 List<String> two = new ArrayList<>(); 9 // ... 10 // 第一个队伍只要名字为3个字的成员姓名； 11 // 第一个队伍筛选以后只要前3我的； 12 Stream<String> streamOne = one.stream().filter(s->s.length() == 3).limit(3); 13 14 // 第二个队伍只要姓张的成员姓名； 15 // 第二个队伍筛选以后不要前2我的； 16 Stream<String> streamTwo = two.stream().filter(s->s.startsWith("张")).skip(2); 17 18 // 将两个队伍合并为一个队伍； 19 // 根据姓名建立Person对象； 20 // 打印整个队伍的Person对象信息。 21 Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println); 22 } 23 }
- 1. Java Stream流之求和
- 2. Java8之流Stream
- 3. java 8 stream 流
- 4. nodeJS之流stream
- 5. Java流（Stream）简介
- 6. JAVA8 之 Stream 流（四）
- 7. Java--Stream流详解
- 8. JAVA8 之 Stream 流（五）
- 9. 流(stream)
- 10. Stream流
- 更多相关文章...
- • ADO Stream 对象 - ADO 教程
- • XSL-FO 流 - XSL-FO 教程
- • Java 8 Stream 教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Java Stream流之求和
- 2. Java8之流Stream
- 3. java 8 stream 流
- 4. nodeJS之流stream
- 5. Java流（Stream）简介
- 6. JAVA8 之 Stream 流（四）
- 7. Java--Stream流详解
- 8. JAVA8 之 Stream 流（五）
- 9. 流(stream)
- 10. Stream流