Stream流

一、什么是Stream流

Stream流操作是Java 8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。
同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。在Stream中的操作每一次都会产生新的流，内部不会像普通集合操作一样立刻获取值，而是 惰性取值 ，只有等到用户真正需要结果的时候才会执行。 并且对于现在调用的方法，本身都是一种高层次构件，与线程模型无关。因此在并行使用中，开发者们无需再去操 心线程和锁了。Stream内部都已经做好了 。
个人的理解：Stream流就好像一座城市的饮用水管线，我们的数据就好像流水一样，在进入我们的管道后，通过各种过滤、杀菌、物质筛查等工序，最终流入千家万户。我们的数据也是一样，最初是比较综合、庞大的数据源，通过我们Stream流的查找、过滤、组合、计算、操作、分组等过程，执行完毕之后获取到我们想要的结果。
Stream流特征：

• Stream流不存储数据
• Stream流不改变数据源
• Stream流不可重复执行

二、Stream流的分类

Stream流根据执行过程可分为：

• 串行流：所谓串行流是指在Stream流执行过程中，在同一线程下逐一执行相应的操作，直到所有操作处理完成。

• 并行流：所谓并行流是指在Stream流执行过程中，在多个线程中分别执行相应的操作，直到所有操作处理完成。
  
  并行流在底层实现中，是沿用了Java7提供的fork/join分解合并框架进行实现。fork根据cpu核数进行数 据分块，join对各个fork进行合并。因并行流是通过多线程进行拆分额整合，所以需要保持线程安全，个人建议不要什么集合都通过Stream流进行操作。

  注意：不是串行流就一定比并行流效率低，更不是流处理就一定比for循环效率低，要根据实际情况慎重选择

三、Stream流常用操作

Stream流多数是对集合或数组进行操作，根据操作的过程，可分为中间操作和终端操作。

• 创建流：在Java8中，Collection 接口被扩展，提供了两个获取流的默认方法。stream()方法返回一个串行流，parallelStream()方法返回一个并行流。
• 中间操作：中间操作会返回一个流，可以通过这种方式将多个流或多个操作连接在一起，形成一个新的链条，从而获得新的流的结果，直到遇到一个终端操作，最终返回一个结果。中间操作又分为无状态操作（不受前一步操作的影响）和有状态操作（需要获取到所有元素后在进行操作）
• 终端操作：终端操作就是通过流的处理最终得到一个结果。终端操作又分为短路操作（遇到符合条件的元素直接获得最终结果）和非短路操作（必须处理完所有元素才能得到最终结果）

操作类型	方法名	方法功能
中间操作	filter	参数是一个boolean类型的Lambda表达式，根据条件获取新的流
中间操作	peek	参数是方法，根据指定的方法对数据进行操作，并且不会改变原有数据，一般用于程序调试
中间操作	map	将Stream中的元素进行函数式变化，将新的元素保存到Stream中
中间操作	mapToXxx	将Stream中的元素转换成对应数值，将新的元素保存到Stream中，可以返回相应数据类型的数组
中间操作	flatMap	将内部的集合转换成为Stream流，再次进行相关操作，实现数据扁平化
中间操作	flatMapToXxx	将内部相关的集合转换成为Stream流，再次进行相关操作，实现数据扁平化
中间操作	skip	将参数的元素跳过再返回一个流，如果流中的元素小于或者等于参数个数，就会返回一个空的流
中间操作	limit	返回指定数量的元素的流。返回的是Stream里前面的参数个数元素
中间操作	distinct	去掉Stream流中的重复项
中间操作	sorted	对Stream流中的元素进行排序，元素是数据，无参为默认排序，元素是对象，可以通过比较器进行比较
终端操作	forEach	循环所有的元素
终端操作	forEachOrdered	循环所有的元素，如果Stream流是并行流，那么forEach不一定按照顺序执行，但forEachOrdered一定按顺序执行
终端操作	toArray	将Stream流转换为数组
终端操作	collect	将Stream流转换为集合

public class Main {
	public static void main(String[] args) {
		List<String> nikeNames=new ArrayList<String>();
		nikeNames.add("1");
		nikeNames.add("2");
		nikeNames.add("3");
		List<User> list=new ArrayList<User>();
		list.add(new User("张三", 20, "男",nikeNames));
		list.add(new User("李四", 32, "男",nikeNames));
		list.add(new User("王五", 12, "女",nikeNames));
		list.add(new User("赵六", 32, "男",nikeNames));
		list.add(new User("钱七", 34, "女",nikeNames));
		list.add(new User("孙八", 21, "男",nikeNames));
		list.add(new User("周九", 54, "女",nikeNames));
		list.add(new User("冯十", 23, "女",nikeNames));
		
		list.stream().filter(user->user.getAge()>18).collect(Collectors.toList()).forEach(System.out::println);
		list.stream().peek(user->System.out.println("会员信息"+user)).forEach(System.out::println);
		list.stream().map(User::getName).forEach(System.out::println);
		list.stream().flatMap(user->user.getNikeNames().stream()).collect(Collectors.toList()).forEach(System.out::println);
		list.stream().limit(2).collect(Collectors.toList()).forEach(System.out::println);
		list.stream().skip(2).collect(Collectors.toList()).forEach(System.out::println);
		list.stream().distinct().forEach(System.out::println);
		list.stream().sorted().forEach(System.out::println);
		list.stream().sorted((u1,u2)->u1.getAge()-u2.getAge()).forEach(System.out::println);
		
	}

}

class User{
	private String name;
	private int age;
	private String sex;
	private List<String> nikeNames;
	
	public User() {
	}
	public User(String name, int age, String sex, List<String> nikeNames) {
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.nikeNames = nikeNames;
	}
	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public List<String> getNikeNames() {
		return nikeNames;
	}

	public void setNikeNames(List<String> nikeNames) {
		this.nikeNames = nikeNames;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
}

四、Stream的特点

• Stream只能处理一次数据：Stream流的从一端获取数据源，在流中依次对元素进行操作，当元素通过流，便无法再对其进行操作，可以重新在数据源获取一个新的流进行操作
• Stream流采用内部迭代方式：对集合进行处理，一般会使用迭代器的遍历方式，这是一种外部迭代；而对于处理Stream流，只要申明处理方式，处理过程由流对象自行完成，这是一种内部迭代，对于大量数据的迭代处理中，内部迭代比外部迭代要更加高效
• Stream流为无存储： Stream流并不存储值；流的元素源自数据源（可能是某个集合、数组或I/O通道等等），通过一系列计算步骤得到
• 函数式风格： 对Stream流的操作会产生一个结果，但流的数据源不会被修改
• 惰性求值： 多数流操作都是以惰性方式实现，一遍遍历完成整个流水线操作，并可以用短路操作提供更高效的实现
• 无需上界： Stream流可以被表达为无限流，用户不停地读取流直到满意的结果出现为止，集合是有限的，但流可以表达为无线流
• 代码简练： 对于一些集合的迭代处理操作，使用Stream流编写可以十分简洁