1. 前言

我在Java8 Stream中讲述了 Java 8 Stream API 的一些内容。今天再看一下peek、map、foreach区别。

2. peek

peek 操作接收的是一个 Consumer 函数。顾名思义 peek 操作会按照 Consumer 函数提供的逻辑去消费流中的每一个元素，同时有可能改变元素内部的一些属性。
这里我们要提一下这个 Consumer 以理解 什么是消费。

2.1 什么是消费 （Consumer）

package java.util.function;

import java.util.Objects;

 
@FunctionalInterface
public interface Consumer<T> {
 
    void accept(T t);

     // 嵌套accept , 顺序为先执行 accept 后执行参数里的 after.accpet
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
 }

Consumer 是一个函数接口。一个抽象方法 void accept(T t) 意为接受一个 T 类型的参数并将其消费掉。其实消费给我的感觉就是 “用掉” ，自然返回的就是 void 。 通常“用掉” T 的方式为两种：

• T 本身的 void 方法 比较典型的就是 setter 。
• 把 T 交给其它接口（类）的 void 方法进行处理 比如我们经常用的打印一个对象 System.out.println(T)

2.2 peek 操作演示

Stream<String> stream = Stream.of("hello", "felord.cn");
 stream.peek(System.out::println);

如果你测试了上面给出的代码你会发现，压根不会按照逻辑跑。这是为啥子呢？ 这是因为流的生命周期有三个阶段：

• 起始生成阶段。
• 中间操作会逐一获取元素并进行处理。 可有可无。所有中间操作都是惰性的，因此，流在管道中流动之前，任何操作都不会产生任何影响。
• 终端操作。通常分为 最终的消费 （foreach 之类的）和 归纳 （collect）两类。还有重要的一点就是终端操作启动了流在管道中的流动。

所以应该改成下面：

Stream<String> stream = Stream.of("hello", "felord.cn");
 List<String> strs= stream.peek(System.out::println).collect(Collectors.toLIst());

比如下图，我们给圆球加了一个框：

3. peek VS map

peek 操作 一般用于不想改变流中元素本身的类型或者只想元素的内部状态时；而 map 则用于改变流中元素本身类型，即从元素中派生出另一种类型的操作。这是他们之间的最大区别。
那么 peek 实际中我们会用于哪些场景呢？比如对 Collection 中的 T 的某些属性进行批处理的时候用 peek 操作就比较合适。 如果我们要从 Collection 中获取 T 的某个属性的集合时用 map 也就最好不过了。

3.1

刚接触java8 Stream的时候，经常会感觉分不清楚 peek 与 map方法的区别其实了解一下λ表达式就明白了

首先看定义

Stream<T> peek(Consumer<? super T> action);

peek方法接收一个Consumer的入参。了解λ表达式的应该明白 Consumer的实现类 应该只有一个方法，该方法返回类型为void。

Consumer<Integer> c =  i -> System.out.println("hello" + i);

而map方法的入参为 Function。

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

Function 的 λ表达式 可以这样写

Function<Integer,String> f = x -> {return  "hello" + i;};

我们发现Function 比 Consumer 多了一个 return。
这也就是peek 与 map的区别了。

总结：peek接收一个没有返回值的λ表达式，可以做一些输出，外部处理等。map接收一个有返回值的λ表达式，之后Stream的泛型类型将转换为map参数λ表达式返回的类型

显而易见，当我们只需要对元素内部处理，使用peek是比较合适的，如果我们需要返回一个自定义的Stream时候，需要使用map

一般peek在Debug场景使用比较方便（官方注释 说了peek用于debug调试使用 官方给的demo也仅仅是打印日志）

/** * peek map */
    @Test
    public void peekAndMapTest() {
        //只需要访问获取内部元素，打印
        List<String> stringList1 = Lists.newArrayList("11", "22", "33");
        stringList1.stream().peek(System.out::print).collect(Collectors.toList());
 
        List<String> stringList2 = Lists.newArrayList("11", "22", "33");
 
        //支持自定义返回值，将字符串转换为数字
        List<Integer> mapResultList = stringList2.stream().map(s -> Integer.valueOf(s)).collect(Collectors.toList());
        System.out.println(mapResultList);
 
        //可以看到返回值还是List<String>
        List<String> peekResultList = stringList2.stream().peek(s -> Integer.valueOf(s)).collect(Collectors.toList());
        System.out.println(peekResultList);
    }

3.2 map

返回一个新的stream，如从一个对象流获取某个属性，返回属性的流

3.3 peek

返回的stream格式不会发生变化，但是可以对stream中的对象的某个属性进行赋值操作等

3.4 foreach

函数返回值是void，如可以单纯对流进行打印操作。也可以先返回集合名，对集合对象中的字段值进行赋值操作等

public class Person {
        private String name;
        private Integer age;
 
        public Person(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
 
        public String getName() {
            return name;
        }
 
        public void setName(String name) {
            this.name = name;
        }
 
        public Integer getAge() {
            return age;
        }
 
        public void setAge(Integer age) {
            this.age = age;
        }
 
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
 
    @Test
    public void testMapPeekForeach() {
        Person p1 = new Person("张三", 19);
        Person p2 = new Person("李四", 21);
        Person p3 = new Person("王五", 17);
 
        List<Person> l1 = Lists.newArrayList(p1, p2, p3);
        List<Integer> l1Ages = l1.stream()
                .map(Person::getAge)
                .collect(Collectors.toList());
        System.out.println("map: " + l1Ages);
 
        List<Person> l2 = Lists.newArrayList(p1, p2, p3)
                .stream()
                .peek(p -> p.setAge(p.getAge() + 10))
                .collect(Collectors.toList());
        System.out.println("peek: " + l2);
 
        List<Person> l3 = Lists.newArrayList(p1, p2, p3);
        l3.forEach(p -> {
            p.setAge(p.getAge() + 10);
            System.out.println("foreach-name: " + p.getName());
        });
        System.out.println("foreach: " + l3);
        
    }

打印结果：

map: [19, 21, 17]
 
peek: [Person{name='张三', age=29}, Person{name='李四', age=31}, Person{name='王五', age=27}]
 
foreach-name: 张三
foreach-name: 李四
foreach-name: 王五
foreach: [Person{name='张三', age=39}, Person{name='李四', age=41}, Person{name='王五', age=37}]

4. 总结

我们今天了解 Stream 的 peek 操作，同时也回顾了 Stream 的生命周期。也顺带对 Consumer 函数进行了讲解。而且 和 map 相互做了比较，对各自的使用场景又做了说明。相信看过本文后你对它们会有更深的理解。