Stream流式思想发布于2020-04-12 00:19:40，更新于2020-06-15 11:45:27，标签：java 文章会持续修订，转载请注明来源地址：https://meethigher.top/blog

1 引言

传统集合的多步遍历代码

几乎所有的集合（如 Collection接口或 Map接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如：

public class Demo01ForEach {
	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<String>();
		list.add("小舞");
		list.add("胡列娜");
		list.add("江厌离");
		for(String s:list) {
			System.out.println(s);
		}
	}
}

这是一段非常简单的集合遍历操作：对集合中的每一个字符串都进行打印输出操作。

循环遍历的弊端

Java 8的Lambda让我们可以更加专注于做什么（What），而不是怎么做（How），这点此前已经结合内部类进行 了对比说明。现在，我们仔细体会一下上例代码，可以发现：

• for循环的语法就是“怎么做”

• for循环的循环体才是“做什么”

为什么使用循环？因为要进行遍历。但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而并不是从 第一个到最后一个顺次处理的循环。前者是目的，后者是方式。

试想一下，如果希望对集合中的元素进行筛选过滤：

1. 将集合A根据条件一过滤为子集B；

2. 然后再根据条件二过滤为子集C。

那怎么办？在Java 8之前的做法可能为：

public class Demo01ForEach {
	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<String>();
		list.add("小舞");
		list.add("胡列娜");
		list.add("江厌离");
		list.add("江澄");
		list.add("江枫眠");
		
		//对list中的元素进行过滤，将以江开头的元素，存储到一个新的集合中
		ArrayList<String> listJiang=new ArrayList<String>();
		for(String s:list) {
			if(s.startsWith("江"))
				listJiang.add(s);
		}
		
		//对listJiang中元素进行过滤，将长度为3的，存储到新的集合中
		ArrayList<String> list3=new ArrayList<String>();
		for(String s:listJiang) {
			if(s.length()==3)
				list3.add(s);
		}
		
		//遍历list3
		for(String s:list3) {
			System.out.println(s);
		}		
	}
}

这段代码中含有三个循环，每一个作用不同：

1. 首先筛选所有姓江的人；

2. 然后筛选名字有三个字的人；

3. 最后进行对结果进行打印输出。

每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循 环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使 用另一个循环从头开始。

那，Lambda的衍生物Stream能给我们带来怎样更加优雅的写法呢？

Stream的更优写法

public class Demo02Stream {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("小舞");
		list.add("胡列娜");
		list.add("江厌离");
		list.add("江澄");
		list.add("江枫眠");

		// 对list中的元素进行过滤，将以江开头的元素，存储到一个新的集合中
		// 对listJiang中元素进行过滤，将长度为3的，存储到新的集合中
		// 遍历list3
		list.stream().filter(new Predicate<String>() {

			@Override
			public boolean test(String s) {
				return s.startsWith("江");
			}
		}).filter(new Predicate<String>() {

			@Override
			public boolean test(String s) {
				return s.length() == 3;
			}
		}).forEach(new Consumer<String>() {

			@Override
			public void accept(String t) {
				System.out.println(t);

			}
		});

		// 升级为Lambda写法，优雅不？艺术不？
		list.stream()
		.filter(s -> s.startsWith("江"))
		.filter(s -> s.length() == 3)
		.forEach(s -> System.out.println(s));
	}
}

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤出姓江、过滤出长度为3、逐一打印。代码中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中。

2 流式思想概述

注意：请暂时忘记对传统IO流的固有印象！

整体来看，流式思想类似于工厂车间的“生产流水线”。

当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤 方案，然后再按照方案去执行它。

这张图中展示了过滤、映射、跳过、计数等多步操作，这是一种集合元素的处理方案，而方案就是一种“函数模型”。图中的每一个方框都是一个“流”，调用指定的方法，可以从一个流模型转换为另一个流模型。而最右侧的数字3是最终结果。

这里的 filter 、 map 、 skip 都是在对函数模型进行操作，集合元素并没有真正被处理。

只有当终结方法 count 执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

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

Stream（流）是一个来自数据源的元素队列，

• 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。

• 数据源 流的来源。 可以是集合，数组等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

• Pipelining： 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。

• 内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭 代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

3 获取流

java.util.stream.Stream 是Java 8新加入的最常用的流接口（这并不是一个函数式接口）

获取一个流非常简单，有以下几种常用的方式：

• 所有的 Collection 集合都可以通过 stream 默认方法获取流；
• Stream 接口的静态方法 of 可以获取数组对应的流。

根据Collection获取流

首先， java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流。

//把集合List转换为Stream
List<String> list=new ArrayList<String>();
Stream<String> stream1=list.stream();
		
Set<String> set=new HashSet<String>();
Stream<String> stream2=set.stream();

根据Map获取流

java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流 需要分key（键）、value（值）或entry（键与值的映射关系）等情况：

Map<String,String> map=new HashMap<String, String>();
//获取键，存储到Set集合中
Set<String> keyset=map.keySet();
Stream<String> stream3=keyset.stream();
		
//或者获取值，存到Collection中，然后再通过Collection集合中的stream默认方法获取流
Stream<String> stream4=map.values().stream();
		
//或者获取键与值的映射关系 entrySet
Set<Map.Entry<String, String>> entries=map.entrySet();
Stream<Map.Entry<String, String>> stream5=entries.stream();

根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法 of ，使用很简单：

//把数组转换为Stream
Stream<Integer> stram6=Stream.of(1,2,3,4,5);
//可变参数可以传递数组
Integer[] arr= {
	1,2,3,4,5
};
Stream<Integer> stream7=Stream.of(arr);

备注： of 方法的参数其实是一个可变参数，所以支持数组

4 常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

• 延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方 法均为延迟方法。）
• 终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。本小节中，终结方法包括 count 和 forEach 方法。

流的特点：Stream流属于管道流，只能被消费（使用）一次。第一个Stream流调用完毕方法，数据就会流转到下一个Stream流， 而这时第一个Stream流已经使用完毕，就会关闭了。所以第一个Stream流就不能再调用方法了。

逐一处理：forEach

虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同。

void forEach(Consumer<? super T> action);

该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。

复习Consumer接口

java.util.function.Consumer<T>接口是一个消费型接口。
//Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。

基本使用：

public class Demo04StreamForEach {
	public static void main(String[] args) {
		//获取一个Stream流
		Stream<String> stream=Stream.of("小舞","朱竹清","水冰儿","胡列娜","邱若水");
		//使用Stream中的forEach方法，对Stream流中的数据进行遍历
//		stream.forEach(new Consumer<String>() {
//
//			@Override
//			public void accept(String t) {
//				System.out.println(t);
//				
//			}
//		});
		
		//改用Lambda优化
		stream.forEach(name->System.out.println(name));
	}
}

过滤：filter

可以通过 filter 方法将一个流转换成另一个子集流。方法签名：

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

复习Predicate接口

此前我们已经学习过 java.util.stream.Predicate 函数式接口，其中唯一的抽象方法为：

boolean test(T t);

该方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的 filter 方法 将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。

基本使用

Stream流中的 filter 方法基本使用的代码如：

public class Demo05StreamFilter {
	public static void main(String[] args) {
		//创建一个Stream流
		Stream<String> stream=Stream.of("朱竹清","宁荣荣","江厌离","胡列娜","火舞","水冰儿","邱若水","水月儿");
		
		//对Stream流中的元素进行过滤，只要姓水的人
//		stream.filter(new Predicate<String>() {
//
//			@Override
//			public boolean test(String t) {
//				// TODO Auto-generated method stub
//				return t.startsWith("水");
//			}
//		}).forEach(name->System.out.println(name));
		
		//Lambda优化
		stream.filter(t->t.startsWith("水")).forEach(name->System.out.println(name));
	}
}

在这里通过Lambda表达式来指定了筛选的条件：必须姓水。

映射：map

如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。

复习Function接口

此前我们已经学习过 java.util.stream.Function 函数式接口，其中唯一的抽象方法为：

R apply(T t);

这可以将一种T类型转换成为R类型，而这种转换的动作，就称为映射。

基本使用

Stream流中的 map 方法基本使用的代码如：

public class Demo06StreamMap {
	public static void main(String[] args) {
		Stream<String> stream=Stream.of("1","2","3","4");
		//使用map方法，将字符串类型的整数，转换（映射）为Integer类型的整数
//		stream.map(new Function<String, Integer>() {
//
//			@Override
//			public Integer apply(String t) {
//				// TODO Auto-generated method stub
//				return Integer.parseInt(t);
//			}
//		}).forEach(num->System.out.println(num));
		
		//优化
		stream.map(t->Integer.parseInt(t)).forEach(num->System.out.println(num));
	}
}

这段代码中， map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对 象）。

统计个数：count

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：

long count();

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：

public class Demo07StreamCount {
	public static void main(String[] args) {
		ArrayList<Integer> list=new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(2);
		list.add(2);
		list.add(2);
		list.add(2);
		list.add(2);
		Stream<Integer> stream=list.stream();
		long count=stream.count();
		System.out.println(count);
	}
}

取用前几个：limit

limit 方法可以对流进行截取，只取用前n个。方法签名：

Stream<T> limit(long maxSize);

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

public class Demo08StreamLimit {
	public static void main(String[] args) {
		String[] girls= {
				"胡列娜","江厌离","邱若水","朱竹清","宁荣荣","火舞","水冰儿","水月儿"
		};
		Stream<String> stream=Stream.of(girls);
		
		//使用limit对Stream流中的元素进行截取，只要前三个元素
		Stream<String> stream2=stream.limit(3);
		stream2.forEach(name->System.out.println(name));
	}
}

limit方法是一个延迟方法，跟filter、map一样，只是对流中的元素进行截取，返回的是一个新流，所以可以继续调用Stream

跳过前几个：skip

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

Stream<T> skip(long n);

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

public class Demo09StreamSkip {
	public static void main(String[] args) {
		String[] girls= {
				"胡列娜","江厌离","邱若水","朱竹清","宁荣荣","火舞","水冰儿","水月儿"
		};
		Stream<String> stream=Stream.of(girls);
		
		//使用skip方法跳过前3个元素
		stream.skip(3).forEach(name->System.out.println(name));
	}
}

组合：concat

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

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

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

该方法的基本使用代码如：

public class Demo10StreamConcat {
	public static void main(String[] args) {
		Stream<String> boys=Stream.of("唐三","戴沐白","魏无羡");
		Stream<String> girls=Stream.of("胡列娜","水冰儿","江厌离");
		Stream<String> stream=Stream.concat(boys, girls);
		stream.forEach(name->System.out.println(name));
	}
}

5 练习：集合元素处理（传统方式）

题目

现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以 下若干操作步骤：

1. 第一个队伍只要名字小于3个字的成员姓名；存储到一个新集合中。
2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
3. 第二个队伍包含水字的成员姓名；存储到一个新集合中。
4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
5. 将两个队伍合并为一个队伍；存储到一个新集合中。
6. 根据姓名创建 Person 对象；存储到一个新集合中。
7. 打印整个队伍的Person对象信息。

代码

class Person {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Person(String name) {
		super();
		this.name = name;
	}

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "Person{name='"+name+"' }";
	}
	
	
	
}
public class Demo11Practice {
	public static void main(String[] args) {
		ArrayList<String> men=new ArrayList<String>();
		men.add("唐三");
		men.add("邪月");
		men.add("焱");
		men.add("江澄");
		men.add("江枫眠");
		
		//存储名字长度小于3
		ArrayList<String> men1=new ArrayList<String>();
		for(String s:men) {
			if(s.length()<3) {
				men1.add(s);
			}
		}
		
		//存储前三个
		ArrayList<String> men2=new ArrayList<String>();
		for(int i=0;i<3;i++) {
			men2.add(men1.get(i));
		}
		
		
		ArrayList<String> women=new ArrayList<String>();
		women.add("胡列娜");
		women.add("水冰儿");
		women.add("火舞");
		women.add("水月儿");
		women.add("邱若水");
		
		
		//存储包含水的
		ArrayList<String> women1=new ArrayList<String>();
		for(String s:women) {
			if(s.contains("水"))
				women1.add(s);
		}
		//存储除前两个以外的
		ArrayList<String> women2=new ArrayList<String>();
		for(int i=2;i<women1.size();i++) {
			women2.add(women1.get(i));
		}
		
		//添加两个集合
		ArrayList<String> all=new ArrayList<String>();
		all.addAll(men2);
		all.addAll(women2);
		
		
		//根据姓名创建Person对象，存储到集合中
		ArrayList<Person> people=new ArrayList<Person>();
		for(String s:all) {
			people.add(new Person(s));
		}
		
		//打印Person集合信息
		for(Person p:people) {
			System.out.println(p);
		}
		
	}
}

看看，这代码写得，麻烦不？代码的艺术呢？我们做了这一系列工作，只是为了最后遍历一下结果而已，循环只是方式，而不是我们的目的。所以，直接采用Stream方式会更加方便

6 练习：集合元素处理（Stream方式）

题目

把上一题当中的传统for循环改为Stream流式处理方式，两个集合的初值保持不变，Person类的定义也不变

代码

public class Demo12Practice {
	public static void main(String[] args) {
		ArrayList<String> men = new ArrayList<String>();
		men.add("唐三");
		men.add("邪月");
		men.add("焱");
		men.add("江澄");
		men.add("江枫眠");

		ArrayList<String> women = new ArrayList<String>();
		women.add("胡列娜");
		women.add("水冰儿");
		women.add("火舞");
		women.add("水月儿");
		women.add("邱若水");

		// 对men,存储名字长度小于3且前3个
		Stream<String> men1=men.stream().filter(name->name.length()<3).limit(3);
		// 对women,存储名字包含水且不包含前2个
		Stream<String> women1=women.stream().filter(name->name.contains("水")).skip(2);
		
		//连接两个，并转存为Person类型，然后遍历
		Stream.concat(men1, women1).map(name->new Person(name)).forEach(person->System.out.println(person));
	}
}