stream-practice
源码下载: https://github.com/Zhang-Jin-Hua/stream-practice
Stream 构建
API
| empty | Stream empty() | empty方法返回一个空的顺序Stream，该Stream里面不包含元素项。 |
| of | Stream of(T… values), Stream of(T t) | of方法，其生成的Stream是有限长度的，Stream的长度为其内的元素个数 |
| concat | Stream concat(Stream<? extends T> a, Stream<? extends T> b) | 将两个Stream合并成一个Stream |
| generator | Stream generate(Supplier s) | 返回无限长度的Stream,其元素由Supplier接口的提供 |
| iterate | Stream iterate(final T seed, final UnaryOperator f) | 返回一个无限长度的Stream，与generate方法不同的是，它是通过函数f对给指定的元素种子不停迭代而产生无限Stream。 f(1) = f(seed(0)), f(2) = f(seed(1)) |
| Collection.stream() | Stream stream() | 在Collection接口中，定义了一个默认方法stream()，用来生成一个Stream |
| Arrays.stream() | Stream stream(T[] array) | 封装了针对数组的Stream方法，可以将数组转化为Stream |
示例
public void initStream() {
//构建空的Stream
Stream<Object> empty = Stream.empty();
//构建非定长的Stream
Stream<Object> objectStream = Stream.of(new Object(), new Object());
//构建单个元素的Stream
Stream<Object> ofStream = Stream.of(new Object());
//将两个Stream合并成一个
Stream<Object> concat = Stream.concat(objectStream, Stream.of());
//根据传入的Supplier生成元素
Stream<Object> generate = Stream.generate(Object::new);
//返回一个无限长度的Stream，与generate方法不同的是，它是通过函数f对给指定的元素种子不停迭代而产生无限Stream
Stream<Object> iterate = Stream.iterate(new Object(), Object::getClass);
//集合类可直接转化为Stream
Collection collection = new ArrayList();
Stream collectionStream = collection.stream();
//将数组转化为Stream
IntStream stream = Arrays.stream(new int[0]);
}
Stream 操作符
API
| distinct | Stream distinct() | 去除掉Stream中重复的元素 |
| filter | Stream filter(Predicate<? super T> predicate) | 对原Stream按照指定条件过滤 |
| map | Stream map(Function<? super T, ? extends R> mapper) | 对于Stream中包含的元素使用给定的转换函数进行转换操作 |
| flatMap | Stream flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) | 与map方法类似，都是将原Stream中的每一个元素通过转换函数转换，不同的是，该换转函数的对象是一个Stream |
| peek | Stream peek(Consumer<? super T> action) | 生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例） |
| skip | Stream skip(long n) | 过滤掉原Stream中的前N个元素 |
| limit | Stream limit(long maxSize) | limit方法将截取原Stream，截取后Stream的最大长度不能超过指定值N |
| sorted | Stream sorted();//对象必须实现Comparable； Stream sorted(Comparator<? super T> comparator); | sorted方法将对原Stream进行排序，返回一个有序列的新Stream |
| reduce | U reduce(U identity, BiFunction |
示例
public void operator() {
//根据传入的Supplier生成元素
Stream<Object> generate = Stream.generate(() -> {
try {
Thread.sleep(ThreadLocalRandom.current().nextInt(1000));
} catch (InterruptedException e) {
//
}
return new Object();
});
{
List<Long> collect = generate
.map(object -> System.currentTimeMillis())
.peek(mills -> System.out.println("before filter:" + mills))
.filter(mills -> mills % 100 > 50)
.peek(mills -> System.out.println("after filter:" + mills))
.skip(2)
.limit(3)
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
System.out.println(collect);
}
{
Optional<Long> min = generate.limit(10)
.map(object -> System.currentTimeMillis())
.min(Comparator.naturalOrder());
}
{
Optional<Object> min = generate.limit(10)
.min(Comparator.comparing(Object::hashCode));
}
{
Optional<Object> max = generate.limit(10)
.max(Comparator.comparing(Object::hashCode));
}
{
List<Object> collect = generate.limit(100)
.distinct()
.map(object -> {
ArrayList<Object> arrayList = new ArrayList<>();
arrayList.add(object);
return arrayList;
})
.flatMap(Collection::stream)
.collect(Collectors.toList());
}
{
Optional<Object> first = generate.limit(100)
.distinct()
.filter(object -> object.hashCode() % 10 > 5)
.findFirst();
Optional<Object> any = generate.limit(100)
.distinct()
.filter(object -> object.hashCode() % 10 > 5)
.findAny();
}
}
