• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

Java8 Stream学习

java 来源:爪哇布道 1次浏览

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();
    }
}


版权声明:本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。
喜欢 (0)