jdk 03.stream

01.集合处理数据的弊端

当我们在需要对集合中的元素进行操作的时候，除了必需的添加，删除，获取外，最典型的操作就是集合遍历

package com.bobo.jdk.stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class StreamTest01 {
	public static void main(String[] args) {
		// 定义一个List集合
		List<String> list = Arrays.asList("张三","张三丰","成龙","周星驰");
		// 1.获取所有 姓张的信息
		List<String> list1 = new ArrayList<>();
		for (String s : list) {
			if(s.startsWith("张")){
				list1.add(s);
			}
		}
		// 2.获取名称长度为3的用户
		List<String> list2 = new ArrayList<>();
		for (String s : list1) {
			if(s.length() == 3){
				list2.add(s);
			}
		}

		for (String s : list2) {
			System.out.println(s);
		}
	}
}

上面的代码针对与我们不同的需求总是一次次的循环循环循环.这时我们希望有更加高效的处理方式，这时我们就可以通过JDK8中提供的Stream API来解决这个问题了。

Stream更加优雅的解决方案：

package com.bobo.jdk.stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class StreamTest02 {
	public static void main(String[] args) {
	// 定义一个List集合
		List<String> list = Arrays.asList("张三","张三丰","成龙","周星驰");
	// 1.获取所有 姓张的信息
	// 2.获取名称长度为3的用户
	// 3. 输出所有的用户信息
		list.stream()
					.filter(s->s.startsWith("张"))
					.filter(s->s.length() == 3)
					.forEach(s->{
						System.out.println(s);
					});
		System.out.println("----------");
		list.stream()
					.filter(s->s.startsWith("张"))
					.filter(s->s.length() == 3)
					.forEach(System.out::println);
	}
}

上面的SteamAPI代码的含义：获取流，过滤张，过滤长度，逐一打印。代码相比于上面的案例更加的简洁直观

0 2. Steam流式思想概述

注意：

Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！

Stream流式思想类似于工厂车间的"生产流水线"，Stream流不是一种数据结构，不保存数据，而是对数据进行加工处理。

Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。

0 3. Stream流的获取方式

1 根据Collection获取

 首先，java.util.Collection 接口中加入了default方法
 stream，也就是说Collection接口下的所有的实现都可以通过steam方法来获取Stream流。

public static void main(String[] args) {
	List<String> list = new ArrayList<>();
	list.stream();
	Set<String> set = new HashSet<>();
	set.stream();
	Vector vector = new Vector();
	vector.stream();
}

但是Map接口别没有实现Collection接口，那这时怎么办呢？这时我们可以根据Map获取对应的key-value的集合。

public static void main(String[] args) {
	Map<String,Object> map = new HashMap<>();
	Stream<String> stream = map.keySet().stream(); // key
	Stream<Object> stream1 = map.values().stream(); // value
	Stream<Map.Entry<String, Object>> stream2 = map.entrySet().stream(); //entry
}

3.1 通过Stream的of方法

在实际开发中我们不可避免的还是会操作到数组中的数据，由于数组对象不可能添加默认方法，

所有Stream接口中提供了静态方法of

public class StreamTest05 {
	public static void main(String[] args) {
	
		Stream<String> a1 = Stream.of("a1", "a2", "a3");
		
		String[] arr1 = {"aa","bb","cc"};
		Stream<String> arr11 = Stream.of(arr1);
		
		Integer[] arr2 = {1,2,3,4};
		Stream<Integer> arr21 = Stream.of(arr2);
		
		arr21.forEach(System.out::println);
		// 注意：基本数据类型的数组是不行的
		int[] arr3 = {1,2,3,4};
		Stream.of(arr3).forEach(System.out::println);
	}
}

4.Stream常用方法介绍

Stream常用方法：

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

终结方法：返回值类型不再是 Stream 类型的方法，不再支持链式调用。

本小节中，

终结方法包括count 和forEach 方法。 非终结方法：返回值类型仍然是 Stream 类型的方法，支持链式调用。

（除了终结方法外，其余方法均为非终结方法。）

Stream注意事项(重要)

1. Stream只能操作一次
2. Stream方法返回的是新的流
3. Stream不调用终结方法，中间的操作不会执行

4.1 forEach

forEach用来遍历流中的数据的

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

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

void forEach(Consumer<? super T> action);
	public static void main(String[] args) {
		Stream.of("a1", "a2", "a3").forEach(System.out::println);;
}

4.2 count

Stream流中的count方法用来统计其中的元素个数的

long count();

该方法返回一个long值，代表元素的个数。

public static void main(String[] args) {
	long count = Stream.of("a1", "a2", "a3").count();
		System.out.println(count);
}

4.3 filter

filter方法的作用是用来过滤数据的。返回符合条件的数据

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

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

该接口接收一个Predicate函数式接口参数作为筛选条件

public static void main(String[] args) {
	Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
		.filter((s)->s.contains("a"))
		.forEach(System.out::println);
}

limit方法可以对流进行截取处理，支取前n个数据，

Stream<T> limit(long maxSize);

参数是一个long类型的数值，如果集合当前长度大于参数就进行截取，否则不操作：

public static void main(String[] args) {
	Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
		.limit(3)
		.forEach(System.out::println);
}