Stream 流使用案例，工作中常用的方法，收集Stream流为集合

package cn.com.learn;  
  
import java.util.*;  
import java.util.stream.Collectors;  
import java.util.stream.Stream;  
  
/**  
* Stream 流学习  
* Lambda表达式，基于Lambda所带来的  
* 函数式编程，又引入了一个全新的Stream概念，  
* 用于解决集合类库既有的弊端。  
*/  
public class StreamLearn {  
  
public static void main(String[] args) {  
// Stream流使用事例  
// test1();  
// 集合获取Stream流  
// test2();  
// Stream流的常用方法  
// test3();  
// 收集Stream流  
test4();  
}  
  
/**  
*Stream流中提供了一个方法，可以把流中的数据收集到单例集合中  
*/  
private static void test4() {  
List<String> list2 = new ArrayList<>();  
list2.add("张老三");  
list2.add("张小三");  
list2.add("李四");  
list2.add("赵五");  
list2.add("张六");  
list2.add("王八");  
  
Stream<String> stream = list2.stream().filter(name -> name.startsWith("张"));  
// stream 流收集到list集合中  
List<String> list = stream.collect(Collectors.toList());  
// stream 流收集到set集合中  
Set<String> set = stream.collect(Collectors.toSet());  
  
}  
  
/**  
* Stream流的常用方法  
* 方法名称 方法作用 方法种类 是否支持链式调用  
* count 统计个数 终结方法 否  
* forEach 逐一处理 终结方法 否  
* filter 过滤 函数拼接 是  
* limit 取用前几个 函数拼接 是  
* skip 跳过前几个 函数拼接 是  
* map 映射 函数拼接 是  
* concat 组合 函数拼接 是  
*/  
private static void test3() {  
//1. 统计流中的元素个数  
List<String> list = new ArrayList<>();  
list.add("张老三");  
list.add("张小三");  
list.add("李四");  
list.add("赵五");  
list.add("张六");  
list.add("王八");  
long count = list.stream().count();  
System.out.println("1. 统计流中的元素个数");  
System.out.println(count);  
//2.获取姓张的元素 3.forEach遍历  
System.out.println("2.获取姓张的元素 3.forEach遍历");  
Stream<String> stream1 = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");  
stream1.filter(name->name.startsWith("张")).forEach(System.out::println);  
//4.limit方法 如果流的长度大于参数，则进行截取；否则不进行操作  
Stream<String> stream2 = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");  
// 截取前三个  
System.out.println("4.limit方法,截取前三个");  
stream2.limit(3).forEach(System.out::println);  
//5.map方法  
Stream<String> stream3 = Stream.of("11","22","33","44","55");  
System.out.println("5.map方法 转成整型并打印");  
stream3.map(Integer::valueOf).forEach(System.out::println);  
//6.skip方法 如果流的当前长度大于n，则跳过前n个，否则将会得到一个长度为0的空流  
Stream<String> stream4 = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");  
System.out.println("6.skip方法 跳过前几个元素");  
stream4.skip(3).forEach(System.out::println);  
//7.concat方法 合并两个流  
Stream<String> stream5 = Stream.of("11","22","33","44","55");  
Stream<String> stream6 = Stream.of("张颜宇", "张三", "李四", "赵五", "刘六", "王七");  
Stream<String> stream7 = Stream.concat(stream5, stream6);  
System.out.println("7.concat方法 合并两个流");  
stream7.forEach(System.out::println);  
  
}  
/**  
* 1.根据List获取流  
* 2.根据Set获取流  
* 3.根据Map获取流  
* 4.根据数组获取流  
*/  
public static void test2(){  
//1. 创建List集合 获取流  
Stream<Object> stream1 = new ArrayList<>().stream();  
//2. 创建Set集合 获取流  
Stream<Object> stream2 = new HashSet<>().stream();  
//3. 创建Map集合 获取流  
HashMap<Integer, String> map = new HashMap<>();  
//3.1 根据Map集合的键获取流  
Stream<Integer> stream3 = map.keySet().stream();  
//3.2根据Map集合的值获取流  
Stream<Map.Entry<Integer, String>> stream = map.entrySet().stream();  
//4.数组获取流  
String[] arr = {"张艳玉","张三","李四","王五"};  
Stream<String> stream4 = Stream.of(arr);  
  
  
}  
/**  
* 需求  
* 将list集合中姓张的元素过滤到一个新的集合中  
* 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中  
*/  
public static void test1() {  
// 已知需求  
List<String> list1 = new ArrayList<>();  
list1.add("张老三");  
list1.add("张小三");  
list1.add("李四");  
list1.add("赵五");  
list1.add("张六");  
list1.add("王八");  
  
// 解答  
List<String> list = list1.stream()  
.filter(name -> name.startsWith("张"))  
.filter(name -> name.length() == 3)  
.collect(Collectors.toList());  
list.forEach(System.out::println);  
}  
}