流的操作分类
中间操作(Intermediate) | 无状态(stateless) | 元素的处理不受之前元素的影响 | unordered(), filter(), map(),mapToInt(), mapToLong(), mapToDouble() , flatMap(), flatMapToInt() , flatMapToLong(),flatMapToDouble(), peek() |
有状态(stateful) | 该操作只有拿到所有元素之后才能继续下去 | distinct(),limit(),sorted(),skip | |
终结操作(terminal) | 非短路操作 | 必须处理所有元素才能得到最终结果 | forEach(),toArray(),forEachOrdered()collect(),max(),min(),count |
短路操作(short-circuting) | 遇到某些符合条件的元素就可以得到最终结果 | anyMatch(),noneMatch(),allMatch(),findFirst(),findAny() | |
- 创建流操作
从一个数据源(如集合、数组)中获取一个流
- Intermediate(中间) 操作
在流后面可以跟0到N个中间操作,其存在的目的是对流的数据进行过滤和映射,然后返回一个新的流,交给下一个操作使用;这类操作都是惰性(lazy)的,也就是说,当调用到这类方法时,其实并未开始流的遍历操作。
- terminal(终结)操作
在整个流生命周期内只内进行一次,且不可逆转的操作;
当这类操作执行之后,流就被完全使用了,不可以再进行其他操作,所以这类操作的使用必定是最后一个流操作。terminal操作的执行,才会真正的开始流的遍历,并且产生一个结果。或者导致一个副作用(side effect)
创建流
从集合创建流
Java8 中的 Collection 接口被扩展了,提供了两个获取流的方法:
- default Stream stream() : 返回一个顺序流
- default Stream parallelStream() : 返回一个并行流
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //获取一个顺序流
Stream<String> parallelStream = list.parallelStream(); //获取一个并行流
从数组创建流
Java8 中的 Arrays 的静态方法 stream() 可以从数组获取流:
- static Stream stream(T[] array): 返回一个流
String[] nums = new String[8];
Stream<String> stream = Arrays.stream(nums);
从静态方法创建流
可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数
- public static Stream of(T… values) : 返回一个流
Stream<Integer> stream = Stream.of(1,2,3,4,5);
IntStream intStream = IntStream.of(new int[]{1,2,3});
IntStream.range(1,3).forEach(System.out::print); // 不包含最大值
IntStream.rangeClosed(1,3).forEach(System.out::print); // 包含最大值
DoubleStream doubleStream = DoubleStream.of(new int[]{1.2d,2.3d,3.4d});
从函数创建流
可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。
- public static Stream iterate(final T seed, final UnaryOperator f)
- public static Stream generate(Supplier s)
Stream.iterate(1, (x) -> x + 1).forEach(System.out::println);
Stream.generate(() -> Math.random()).forEach(System.out::println);
流转换为其他数据结构
Stream stream = Stream.of("a", "b", "c");
// 转换为数组
String[] strings = (String[]) stream.toArray(String[]::new);
// 转换为集合List
List<String> list1 = (List<String>) stream.collect(Collectors.toList());
// 转换为集合List的子类ArrayList
List<String> list2 = (List<String>) stream.collect(Collectors.toCollection(ArrayList::new));
// 转换为集合Set
Set set1 = (Set) stream.collect(Collectors.toSet());
// 转换为栈
Stack stack1 = (Stack) stream.collect(Collectors.toCollection(Stack::new));
//转换为字符串
String str = stream.collect(Collectors.joining(",")).toString();
Intermediate(中间操作)
在创建出流以后,我们就可以进行中间操作了。多个中间操作可以连接起来形成一个流水线,除非流水线上触发terminal(终止)操作,否则中间操作不会执行任何的处理!而在终止操作时一次性全部处理,称为“惰性(lazy)求值”
中间操作按照使用功能划为又可以分为四类
- 筛选
- 切割
- 排序
- 映射
按照操作数据的状态又可以分为两类
- 有状态 – 元素的处理不受之前元素的影响
- 无状态 – 该操作只有拿到所有元素之后才能继续下去
筛选
Stream中进行筛选操作有两个方法
Stream filter(Predicate<? super T> predicate);
List<User> users = new ArrayList<>();
users.add(new User("zhangsan",18,""));
users.add(new User("lisi",26,""));
users.add(new User("米酒",40,""));
users.add(new User("郝十",18,""));
筛选年龄大于18岁的用户,并进行循环输出
users.stream()
.filter(user->user.getAge()>18)
.forEach(System.out::println);
Stream distinct();
根据流所生成元素的 hashCode() 和 equals() 去除重复元素
User user = new User("zhangsan",18,"");
users.add(user);
users.add(new User("lisi",26,""));
users.add(new User("米酒",40,""));
users.add(new User("郝十",18,""));
users.add(user);
// 输出全部用户
users.stream().forEach(System.out::println);
// 输出去重后的全部用户
users.stream().distinct().forEach(System.out::println);
切割
Stream 中对流的切割也有两种切割方法,limit()从0开始到maxSize切割流, skip() 从指定位置开始切割至流末尾。
Stream limit(long maxSize);
截取元素长度不大于maxSize的元素,组成一个新的Stream.
Stream<Integer> integerStream = Stream.of(1,2,3,4,5,6,7,8,9,0);
integerStream.limit(5).forEach(System.out::println);
Stream skip(long n);
丢弃流的前n个元素,如果流所包含的元素少于n个,那么返回一个空的stream.
Stream<Integer> integerStream = Stream.of(1,2,3,4,5,6,7,8,9,0);
integerStream.skip(5).forEach(System.out::println);
排序
Stream 对排序有两种方法
Stream sorted();
按照自然顺序排序,如果流元素不是Comparator的,则当执行Terminal操作的时候将抛出类型转换异常ava.lang.ClassCastException
Stream<Integer> integerStream = Stream.of(20,2,30,12,70);
integerStream.sorted().forEach(System.out::println);
Stream sorted(Comparator<? super T> comparator);
根据提供的Comparator 进行排序,源码中说,对于顺序流,排序是稳定的,对于无序流,不保证排序的稳定性
List<User> users = new ArrayList<>();
users.add(new User("lisi",26,""));
users.add(new User("米酒",40,""));
users.add(new User("郝十",18,""));
users.stream().sorted(Comparator.comparing(User::getAge)).forEach(System.out::println);
映射
Stream map(Function<? super T, ? extends R> mapper);
List<User> users = new ArrayList<>();
users.add(new User("lisi",26,""));
users.add(new User("米酒",40,""));
users.add(new User("郝十",18,""));
users.stream().map(User::getName).forEach(System.out::println);
Stream<Integer> integerStream = Stream.of(20,2,30,12,70);
integerStream.map(w->w*10).forEach(System.out::println);
IntStream mapToInt(ToIntFunction<? super T> mapper); 返回一个IntStream映射
LongStream mapToLong(ToLongFunction<? super T> mapper); 返回一个LongStream映射
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper); 返回一个DoubleStream映射
与map()方法类似,只不过返回的是对应封装类型的Stream