Java之Stream流
一、什么是Stream流
Stream是一种处理集合（Collection）数据的方式。Stream可以让我们以一种更简洁的方式对集合进行过滤、映射、排序等操作。
二、Stream流的使用步骤
- 先得到一条Stream流，并把数据放上去
- 利用Stream流中的API进行各种操作
- 中间操作
- 过滤（filter）
- 去重（distinct）
- 终止操作
- 统计
- 打印
三、Stream流的特点
结构化处理：Stream提供了一种结构化的方式来处理集合数据，可以使用一系列的操作来处理数据，而不是通过循环遍历集合。
链式操作：Stream的操作可以进行链式调用，形成一个操作流水线，每个操作都会作用于前一个操作的结果上。
惰性求值：Stream的操作是惰性求值的，只有在终止操作时才会触发执行，这样可以避免不必要的计算。
并行执行：Stream可以以并行的方式执行操作，可以充分利用多核处理器的优势提高程序的性能。
四、获取流的方式
| 获取方式 | 方法名 | 说明 |
| 单列集合 | default Stream<E> stream() | Collection中的默认方法 |
| 双列集合 | 无 | 无法直接使用stream流 |
| 数组 | public static <T> Stream<T> stream(T[] array) | Arrays工具类中的静态方法 |
| 一堆零散数据 | public static<T> Stream<T> of(T...values) | Stream接口中的静态方法 |
// 单列集合
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b", "c", "d", "e", "f");Stream<String> stream = list.stream();
stream.forEach(s -> System.out.println(s));// 双列集合
HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa", 111);
hm.put("bbb", 222);
hm.put("ccc", 333);
hm.put("ddd", 444);// 第一种
hm.keySet().stream().forEach(s -> System.out.println(s));// 第二种
hm.entrySet().stream().forEach(s -> System.out.println(s));// 数组
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};Arrays.stream(arr).forEach(s-> System.out.println(s));// 一堆零散数据
// 必须是同一种数据
Stream.of(1,2,3,4,5,6,7).forEach(s-> System.out.println(s));Stream.of("a","b","c","d","e").forEach(s-> System.out.println(s));五、Stream流的中间方法
| Stream<T> filter(Predicate<? super T> predicate) | 过滤 |
| Stream<T> limit(long maxSize) | 获取前几个元素 |
| Stream<T> skip(long n) | 跳过前几个元素 |
| Stream<T> distinct() | 元素去重（依赖hashcode和equals方法） |
| static <T> Stream<T> concat(Stream a,Stream b) | 合并a和b两个流为一个流 |
| Stream<R> map(Function<T,R> mapper) | 转换流中的数据类型 |
注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");// filter 过滤
list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));// limit 获取前几个元素
list.stream().limit(2).forEach(s -> System.out.println(s));// skip 跳过前几个元素
list.stream().skip(2).forEach(s -> System.out.println(s));ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌", "张无忌", "张无忌", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2, "周芷若", "赵敏");// distinct 元素去重（依赖hashcode和equals方法）
list1.stream().distinct().forEach(s -> System.out.println(s));// concat 合并a和b两个流为一个流
Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-20", "周芷若-18", "赵敏-19", "张强-30", "张三丰-69", "张翠山-25", "张良-29", "王二麻子-54", "谢广坤-58");// Stream<R> map(Function<T,R> mapper) 转换流中的数据类型
// 第一个类型：流中原本的数据类型
// 第二个类型：要转成之后的类型
// apply的形参s：依次表示流里面的每一个数据
// 返回值：表示转换之后的数据//当map方法执行完毕后，流上的数据就变成了整数
//随意在下面forEach当中，s依次表示流里面的每一个数据，这个数据现在是整数
list.stream().map(new Function<String, Integer>() {@Overridepublic Integer apply(String s) {String[] arr = s.split("-");return Integer.parseInt(arr[1]);}
}).forEach(s -> System.out.println(s));System.out.println("========");// lambda表达式的形式
list.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s -> System.out.println(s));六、Stream流的终结方法
| void forEach(Consumer action) | 遍历 |
| long count() | 统计 |
| toArray() | 收集流中的数据，放到数组中 |
| collect(Collector collector) | 收集流中的数据，放到集合中 |
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");// void forEach(Consumer action) 遍历
list.stream().forEach(s -> System.out.println(s));// long count() 统计
long count = list.stream().count();
System.out.println(count);// toArray() 收集流中的数据，放到数组中
Object[] obj = list.stream().toArray();
System.out.println(Arrays.toString(obj));// IntFunction的泛型：具体类型的数组
// apply的形参：流中数据的个数，要跟数组的长度保持一致
// apply的返回值：具体类型的数组
// 方法体：就是创建数组
String[] arr = list.stream().toArray(new IntFunction<String[]>() {@Overridepublic String[] apply(int value) {return new String[value];}
});
System.out.println(Arrays.toString(arr));// lambda表达式的形式
String[] arr = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr));// collect(Collector collector) 收集流中的数据，放到集合中
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-男-32", "周芷若-女-18", "赵敏-女-19", "张强-男-26", "张三丰-男-45", "张翠山-男-24", "张良-男-23", "王二麻子-男-48", "谢广坤-男-56");// 收集到List集合
// 收集男性
List<String> collect = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toList());
System.out.println(collect);// 收集到Set集合中
// 收集男性
// 会去重
Set<String> collect1 = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toSet());
System.out.println(collect1);// 收集到Map集合
// 收集男性,键：姓名，值：年龄
// 键不能重复
/*
toMap:参数一表示键的生成规则参数二表示值的生成规则参数一：Function泛型一：表示流中每一个数据的类型泛型二：表示map集合中键的数据类型apply形参：依次表示流里面的每一个数据方法体：生成键的代码返回值：已经生成的键参数二：Function泛型一：表示流中每一个数据的类型泛型二：表示map集合中值的数据类型apply形参：依次表示流里面的每一个数据方法体：生成键的代码返回值：已经生成的键*/
Map<String, Integer> map = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap(new Function<String, String>() {@Overridepublic String apply(String s) {return s.split("-")[0];}
}, new Function<String, Integer>() {@Overridepublic Integer apply(String s) {return Integer.parseInt(s.split("-")[2]);}
}));
System.out.println(map);// lambda表达式的形式
Map<String, Integer> map1 = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap(s -> s.split("-")[0],s -> Integer.parseInt(s.split("-")[2])
));
System.out.println(map1);lambda表达式详解