Java 8 Stream简介和“复用”的问题

List menu = new ArrayList<>();
        menu.add(new Dish("鱼香肉丝",500));
        menu.add(new Dish("鱼香茄子",800));
        menu.add(new Dish("红烧茄子",1000));

List names = menu.stream()
                .filter(dish -> {
                    System.out.println("filtering"+ dish.getName());
                    return dish.getCalories()>100;
                })
                .map(dish -> {
                    System.out.println("mapping" + dish.getName());
                    return dish.getName();
                })
                .limit(2)
                .collect(Collectors.toList());

/**
     * Returns a stream consisting of the elements of this stream that match
     * the given predicate.
     *
     * This is an intermediate
     * operation.
     *
     * @param predicate a non-interfering,
     *                  stateless
     *                  predicate to apply to each element to determine if it
     *                  should be included
     * @return the new stream
     */
    Stream filter(Predicate predicate);

 /**
     * Returns whether all elements of this stream match the provided predicate.
     * May not evaluate the predicate on all elements if not necessary for
     * determining the result.  If the stream is empty then {@code true} is
     * returned and the predicate is not evaluated.
     *
     * This is a short-circuiting
     * terminal operation.
     *
     * @apiNote
     * This method evaluates the universal quantification of the
     * predicate over the elements of the stream (for all x P(x)).  If the
     * stream is empty, the quantification is said to be vacuously
     * satisfied and is always {@code true} (regardless of P(x)).
     *
     * @param predicate a non-interfering,
     *                  stateless
     *                  predicate to apply to elements of this stream
     * @return {@code true} if either all elements of the stream match the
     * provided predicate or the stream is empty, otherwise {@code false}
     */
    boolean allMatch(Predicate predicate);

        List menu = new ArrayList<>();
        menu.add(new Dish("鱼香肉丝",500));
        menu.add(new Dish("鱼香茄子",800));
        menu.add(new Dish("红烧茄子",1000));
        menu.add(new Dish("红烧鲍鱼",2000));

        List dishes = menu.stream()
                .filter(dish -> dish.getCalories()>300)
                .limit(3)
                .collect(Collectors.toList());

        System.out.println(dishes);

List lists = new ArrayList<>();
        lists.add(new User("张三",22));
        lists.add(new User("张三",21));
        lists.add(new User("李四",22));
        lists.add(new User("张三",21));

        List collect = lists.stream().filter(user -> user.getAge() < 22).collect(Collectors.toList());

        List collect1 = lists.stream().filter(user -> user.getAge() > 50).collect(Collectors.toList());

    /**
     * Returns a sequential {@code Stream} with this collection as its source.
     *
     * This method should be overridden when the {@link #spliterator()}
     * method cannot return a spliterator that is {@code IMMUTABLE},
     * {@code CONCURRENT}, or late-binding. (See {@link #spliterator()}
     * for details.)
     *
     * @implSpec
     * The default implementation creates a sequential {@code Stream} from the
     * collection's {@code Spliterator}.
     *
     * @return a sequential {@code Stream} over the elements in this collection
     * @since 1.8
     */
    default Stream stream() {
        return StreamSupport.stream(spliterator(), false);
    }

  /**
     * Creates a new sequential or parallel {@code Stream} from a
     * {@code Spliterator}.
     *
     * The spliterator is only traversed, split, or queried for estimated
     * size after the terminal operation of the stream pipeline commences.
     *
     * It is strongly recommended the spliterator report a characteristic of
     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
     * late-binding.  Otherwise,
     * {@link #stream(java.util.function.Supplier, int, boolean)} should be used
     * to reduce the scope of potential interference with the source.  See
     * Non-Interference for
     * more details.
     *
     * @param  the type of stream elements
     * @param spliterator a {@code Spliterator} describing the stream elements
     * @param parallel if {@code true} then the returned stream is a parallel
     *        stream; if {@code false} the returned stream is a sequential
     *        stream.
     * @return a new sequential or parallel {@code Stream}
     */
    public static  Stream stream(Spliterator spliterator, boolean parallel) {
        Objects.requireNonNull(spliterator);
        return new ReferencePipeline.Head<>(spliterator,
                                            StreamOpFlag.fromCharacteristics(spliterator),
                                            parallel);
    }