Java8 關於stream.foreach()和stream.peek()的區別解析

改思考來源於日常工作中，特記此心得。

 

思考：如何快速將list中的每個item內部屬性值改變並進行其他流體操作呢？

下面做個測試：如何先在list中統一改變某屬性的值，然后再根據某個屬性取出該屬性值最小的對象

 

1：隨便新建一個測試bean:

 

package com.dev.model;

import javax.persistence.*;

public class Aopi {
    /**
     * id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 年齡
     */
    private Integer age;

    /**
     * 獲取id
     *
     * @return id - id
     */
    public Integer getId() {
        return id;
    }

    /**
     * 設置id
     *
     * @param id id
     */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
     * 獲取姓名
     *
     * @return name - 姓名
     */
    public String getName() {
        return name;
    }

    /**
     * 設置姓名
     *
     * @param name 姓名
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 獲取年齡
     *
     * @return age - 年齡
     */
    public Integer getAge() {
        return age;
    }

    /**
     * 設置年齡
     *
     * @param age 年齡
     */
    public void setAge(Integer age) {
        this.age = age;
    }

    public Aopi(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Aopi() {
    }

    @Override
    public String toString() {
        return "Aopi{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 

 

 

2：新建一個單元測試：

 

    @Test
    public void test01() {
        List<Aopi> aopiList = Lists.newArrayList();

        Aopi aopi = new Aopi("1", 1);
        Aopi aop2 = new Aopi("2", 2);
        Aopi aop3 = new Aopi("3", 3);
        Aopi aop4 = new Aopi("4", 4);

        aopiList.addAll(Arrays.asList(aopi, aop2, aop3, aop4));

        //第一種方式
        aopiList.forEach(item -> item.setName(item.getName() + "_test"));
        System.out.println(
                aopiList.stream().min((o1, o2) -> {
                    if (Objects.equals(o1.getAge(), o2.getAge()))
                        return 0;
                    return o1.getAge() > o2.getAge() ? 1 : -1;
                }).get().toString()
        );

        System.out.println("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz");

        //第二種方式
        System.out.println(
                aopiList.stream().peek(item -> item.setName(item.getName() + "_test")).min((o1, o2) -> {
                    if (Objects.equals(o1.getAge(), o2.getAge()))
                        return 0;
                    return o1.getAge() > o2.getAge() ? 1 : -1;
                }).get().toString()
        );

    }

 

notice1：測試第一種方式注釋掉第二種，反之亦如此

notice2：list.stream().foreach  ->  list.foreach()

 

 

3：看測試結果：

第一種測試結果：

 

第二種測試結果：

 

 

結論：

（1）：使用stream.foreach也可以更改list中的每個item的內部屬性值等等，但是要進行“二次流處理”，才能得到list中最小的item（根據age篩選）

（2）：stream.peek比stream.foreach()可以跟直接拿到最小的item（根據age篩選）

 

原因：

（1）：stream.foreach的操作是void的，除了更改屬性值還可以進行其他操作等。因此要做“二次流處理”。

    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

（1）：stream.peek的操作是返回一個新的stream的，且設計的初衷是用來debug調試的，因此使用steam.peek()必須對流進行一次處理再產生一個新的stream。

    /**
     * Returns a stream consisting of the elements of this stream, additionally
     * performing the provided action on each element as elements are consumed
     * from the resulting stream.
     *
     * <p>This is an <a href="package-summary.html#StreamOps">intermediate
     * operation</a>.
     *
     * <p>For parallel stream pipelines, the action may be called at
     * whatever time and in whatever thread the element is made available by the
     * upstream operation.  If the action modifies shared state,
     * it is responsible for providing the required synchronization.
     *
     * @apiNote This method exists mainly to support debugging, where you want
     * to see the elements as they flow past a certain point in a pipeline:
     * <pre>{@code
     *     Stream.of("one", "two", "three", "four")
     *         .filter(e -> e.length() > 3)
     *         .peek(e -> System.out.println("Filtered value: " + e))
     *         .map(String::toUpperCase)
     *         .peek(e -> System.out.println("Mapped value: " + e))
     *         .collect(Collectors.toList());
     * }</pre>
     *
     * @param action a <a href="package-summary.html#NonInterference">
     *                 non-interfering</a> action to perform on the elements as
     *                 they are consumed from the stream
     * @return the new stream
     */
    Stream<T> peek(Consumer<? super T> action);

 

bye~^_^