前言
Stream是一个来自数据源的元素队列并支持聚合操作，其中具有以下特性：
- Stream只负责计算，不存储任何元素，元素是特定类型的对象，形成一个队列
- 数据源可以实集合、数组、I/O channel、generator等
- 聚合操作有类似SQL的：filter、map、match、sorted等操作
- Stream流的执行类似于懒加载，用户使用时才执行相应操作
- 可消费性；Stream只能被消费一次，被消费后需要重新生成
本文总结了部分在日常开发中经常接触到的一些Stream流相关的方法，不足之处或有错误欢迎留评，总结的几个方法如下：
- void forEach() : 迭代流中的数据
- Stream map() : 用于映射每个元素到对应的结果
- Stream filter() : 条件过滤器
- Stream sorted() : 排序
- R collect() : 流数据 -> 集合/数组
- 待补充…
forEach()
forEach()源码：
void forEach(Consumer<!--? super T--> action);
Stream().forEach() : 迭代流中的数据
forEach() 的返回类型为void，不会产生新的流
举个栗子：
public void testForEach() {
/**
* 使用forEach()内部迭代
* ints()表示整数类型
* limit()表示限制流个数(次数)
*/
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);
}
运行结果：
再举个灵活一点的栗子：
public void testForEach() {
/**
* 使用forEach()转换集合类型，如List->Map
*/
AtomicInteger i = new AtomicInteger();//原子类型
Map<Integer,String> map = new HashMap<>();
List<String> list = new ArrayList<>(Arrays.asList("Hello",",","world"));
list.stream().forEach(s->{
map.put(i.getAndIncrement(),s);
});
}
对于forEach()方法在本人日常开发中常用于：
- 使用内循环对集合进行遍历
- 使用foreach方法将List转为Map形式
map()
map()源码：
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
Stream().map() 用于映射每个元素到对应的结果
返回类型为Stream，map()会产生新的流并返回
举个栗子：
public void testMap(){
/**
* map()获取list每个元素的平方值
* distinct()去重操作
* collect()将map()产生的新的流转为List类型
*/
List<Integer> list = Arrays.asList(1,2,3);
list.stream().map(num -> num * num)
.distinct()
.collect(Collectors.toList())
.forEach(System.out::println);
}
filter()
filter()源码：
Stream<T> filter(Predicate<? super T> predicate);
Stream().filter()为条件过滤器
举个栗子：
public void testFilter(){
/**
* filter()过滤空字符串
* count()统计符合条件的个数，返回类型long
*/
List<String> list = new ArrayList<>(Arrays.asList("ab","","abc","","acd"));
long count = list.stream()
.filter(str -> str.isEmpty())
.count();
}
sorted()
sorted()源码：
Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);
Stream支持两种方式的排序：
- 无参方法默认为自然排序
- sorted(Comparator comp) 按自定义比较器进行排序
仍然是举个栗子：
1)无参方法
public void testSorted(){
/**
* sort()无参默认为自然排序
* 返回类型Stream 会产生新的流
*/
List<String> list = new ArrayList<>(Arrays.asList("aaa","ccc","bbb"));
list.stream().sorted().forEach(System.out::println);
}
执行结果：
2）带参方法（User类由name和age组成）
- 先比较年龄，按从小到大排序
- 若年龄相等，则按性名自然排序
public void testSorted(){
/**
* sort(Comparator comp)按自定义比较器进行排序
* 返回类型同样是Stream 会产生新的流
*/
List<User> userList = new ArrayList<>(Arrays.asList(
new User("zhangsan",22),
new User("wangwu",22),
new User("badao",32),
new User("kongfu",16)
));
Stream<User> sorted = userList.stream().sorted((x, y) -> {
if (x.getAge() == y.getAge()) { // 使用流中的序列两两进行比较
return x.getName().compareTo(y.getName());
} else {
return x.getAge() - y.getAge();//顺序
// y.getAge() - x.getAge() 为逆序
}
});
sorted.forEach(System.out::println);
}
执行结果：
collect()
collect()源码：
<R> R collect(Supplier<R> supplier,
BiConsumer<R, ? super T> accumulator,
BiConsumer<R, R> combiner);
stream().collect() 由三个参数构成 :
- Supplier 生产者，返回最终结果
- BiConsumer<R, ? super T> accumulator，累加器 :
其中 R 为要返回的集合， ? super T 为遍历过程中的每个参数，相当于add操作
- BiConsumer<R,R> combiner，合并器 :
有并行流时才会使用，相当于将第二部操作形成的list添加到最终的list，addAll操作
举个栗子：
1）new()
public void testCollect(){
Stream<String> stream = Stream.of("hello","world","hello,world");
// new()
List<String> list = stream.collect(Collectors.toList());//List
// 指定集合类型，如ArrayList
ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));
//Set
stream.collect(Collectors.toSet());
// 指定HashSet
HashSet<String> hashSet = stream.collect(Collectors.toCollection(HashSet::new));
// 拼接字符串
String str = stream.collect(Collectors.joining());
2）new() -> add() -> addAll()
public void testCollect(){
/**
* 参数传递行为相当于: new() -> add() -> addAll()
*/
Stream<String> stream = Stream.of("hello","world","hello,world");
// new() -> add() -> addAll()完整演示
HashMap<String,String> map = stream.collect(HashMap::new,(x,y)->{
x.put(y,y); // x 为集合，y 为当前遍历元素，以当前遍历元素作为kv
},HashMap::putAll);
map.forEach((x,y)->{
System.out.println(x+" : "+y);
});
执行结果：
