山寨Stream API设计分析
作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO
联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬
私以为，Java8最显著的新特性就2个：
- Lambda表达式
- Stream API
其中，Lambda表达式最“难”。它的“难”在于抽象，初学者根本不知道为什么要这么写、写了又如何起作用。
好在《Lambda表达式》已经解答了这个问题。
世界上有两种答案，真理or你期望的答案。个人觉得，对于Lambda表达式和Stream API，我们只要得到期望的答案即可。Lambda表达式底层到底是不是匿名内部类呢？其实不是。但这不妨碍我们认为Lambda表达式是“掐头去尾”的匿名内部类，然后顺手再把Stream API学了，马上应用到实战中。这，才是最重要的。
Lambda底层原理其实是自动生成一个私有静态方法，并实现函数式接口，然后在函数式接口实现类的方法中调用这个私有静态方法。如果感兴趣可以自己百度一下，会有一些反编译操作。
之前提到过，我曾放弃学习Java8，因为太抽象了，被各种视频绕晕了。首先，视频没有把Lambda表达式讲清楚，其次Stream API也讲得不好。初学者老想知道底层发生了什么，而老师却连每次调用的方法做了什么也解释得很含糊。
接下来，希望通过对山寨版的Stream API的分析，帮大家更好地理解Java8的Stream API。
本篇文章具有一定难度，请确保已经看过Lambda表达式及山寨Stream API。
模拟Stream API：filter()
请按顺序阅读以下代码：
/**
* 新建Predicate接口
*
* @param
*/
@FunctionalInterface
interface Predicate {
/**
* 定义了一个test()方法，传入任意对象，返回true or false，具体判断逻辑由子类实现
*
* @param t
* @return
*/
boolean test(T t);
}
/**
* Predicate接口的实现类，泛型规定只处理Person
*/
class PredicateImpl implements Predicate {
/**
* 判断逻辑是：传入的person是否age>18，是就返回true
*
* @param person
* @return
*/
@Override
public boolean test(Person person) {
return person.getAge() > 18;
}
}
@Data
@AllArgsConstructor
class Person {
private String name;
private Integer age;
} 目前为止，和Stream API没任何关系，相信大家都能看得懂。
测试：
public class MockStream {
public static void main(String[] args) {
Person bravo = new Person("bravo", 18);
// 1.具体实现类，调用它的test()方法
Predicate predicate1 = new PredicateImpl();
// test()内部代码是：bravo.getAge() > 18
myPrint(bravo, predicate1); // false
// 2.匿名类，调用它的test()方法
Predicate predicate2 = new Predicate() {
@Override
public boolean test(Person person) {
return person.getAge() < 18;
}
};
myPrint(bravo, predicate2); // false
// 3.Lambda表达式，调用它的test()方法。
// 按照Lambda表达式的标准，只要你是个函数式接口，那么就可以接收Lambda表达式
Predicate predicate3 = person -> person.getAge() == 18;
myPrint(bravo, predicate3); // true
}
public static void myPrint(Person person, Predicate filter) {
if (filter.test(person)) {
System.out.println("true");
} else {
System.out.println("false");
}
}
} 上面的代码，估计有一部分基础稍差的同学开始晕了，我们来理一下。
myPrint(Person person, Predicate
而实现test()的诀窍在于，盯牢它的入参和出参。它有一个入参（待测试目标），而返回值是一个boolean（测试结果）。这还不简单，我随随便便就能瞎写一个：
// 1.普通的方法
public boolean test(Person p) {
// 啥逻辑都没有，直接返回true，你也可以按照实际业务写，比如p.age>18
return true;
}
// 2.Lambda形式
p -> return true;之前提到过，在函数式接口的前提下，接口多态可以直接看作是方法多态，那么Filter#test()其实就是抽象方法占坑，实现类、匿名类或者Lambda表达式就可以指向它。就像之前说的，不管你先放鸡翅还是先倒可乐，我先用twoStep()占坑，你后面确定了自己传进来。
上面3个例子，重要的不是结论，而是想揭露一个事实
不论具体实现类、匿名类还是Lambda表达式，其实做的事情本质上是一样的：
1.先让函数式接口占坑
2.自己不慌不忙制定映射规则，规则可以被藏在具体类、匿名类中，或者Lambda表达式本身
有了上面的铺垫，我们来仔细看看之前山寨Stream API对filter()的实现：
class MyList{
private List list = new ArrayList<>();
// 1.外部调用add()添加的元素都会被存在list
public boolean add(T t) {
return list.add(t);
}
/**
* 过滤方法，接收过滤规则
* @param predicate
* @return
*/
public List filter(Predicate predicate){
List filteredList = new ArrayList<>();
for (T t : list) {
// 2.把规则应用于list
if (predicate.test(t)) {
// 3.收集符合条件的元素
filteredList.add(t);
}
}
return filteredList;
}
} - filter(Predicate predicate)方法需要一个过滤规则，但这个规则不能写死，所以随便搞了一个接口占坑
- 具体的过滤规则被延迟到传入具体类实例或Lambda时才确定
你可以理解为就是对策略模式的应用，但函数式接口更喜欢接收Lambda表达式，代码更加简洁。
Predicate接口已经提前占好坑位，而Lambda们则是去填坑。对于filter()这个案例而言，它需要外界传入具体的“判断器”，然后filter()内部让元素挨个排队去做检查，检查通过就加入filteredList，然后一起返回。
不关注Predicate接口接收的是谁（匿名对象/具体实现/Lambda），只关心它能干什么（方法）。这也是面向对象和函数式编程的思维差异
最终代码（最好在SpringBoot环境下运行）：
public class MockStream {
public static void main(String[] args) throws JsonProcessingException {
MyList personMyList = new MyList<>();
personMyList.add(new Person("李健", 46));
personMyList.add(new Person("周深", 28));
personMyList.add(new Person("张学友", 59));
// 过渡1：把Lambda赋值给变量，然后在传递
Predicate predicate = person -> person.getAge() > 40;
List filteredList = personMyList.filter(predicate);
prettyPrint(filteredList);
System.out.println("\n---------------------------------------------\n");
// 不像Stream API？这样写呢？
List filter = personMyList.filter(person -> person.getAge() > 40);
prettyPrint(filter);
// 不要问我为什么没有stream()和collect()，问就是不会写。
System.out.println("\n---------------------------------------------\n");
// 有请真正的Stream API（要用真的List了，不能用山寨MyList）
List list = new ArrayList<>();
list.add(new Person("李健", 46));
list.add(new Person("周深", 28));
list.add(new Person("张学友", 59));
List collect = list.stream().filter(person -> person.getAge() > 40).collect(Collectors.toList());
prettyPrint(collect);
}
/**
* 按JSON格式输出
*
* @param obj
* @throws JsonProcessingException
*/
private static void prettyPrint(Object obj) throws JsonProcessingException {
ObjectMapper objectMapper = new ObjectMapper();
String s = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
System.out.println(s);
}
}
// 省略Predicate、Person、MyList 模拟Stream API：map()
再模拟一个map()。因为实际编程中，个人认为filter()和map()是最常用的，希望大家能理解它们的“原理”。
/**
* 定义一个Function接口
* 从接口看Function中，E(Enter)表示入参类型，R(Return)表示返回值类型
*
* @param 入参类型
* @param 返回值类型
*/
@FunctionalInterface
interface Function {
/**
* 定义一个apply()方法，接收一个E返回一个R。也就是把E映射成R
*
* @param e
* @return
*/
R apply(E e);
}
/**
* Function接口的实现类，规定传入Person类型返回Integer类型
*/
class FunctionImpl implements Function {
/**
* 传入person对象，返回age
*
* @param person
* @return
*/
@Override
public Integer apply(Person person) {
return person.getAge();
}
} public class MockStream {
public static void main(String[] args) {
Person bravo = new Person("bravo", 18);
// 1.具体实现类，Function中，Person是入参类型，Integer是返回值类型
Function function1 = new FunctionImpl();
myPrint(bravo, function1);
// 2.匿名类
Function function2 = new Function() {
@Override
public Integer apply(Person person) {
return person.getAge();
}
};
myPrint(bravo, function2);
// 3.Lambda表达式 person（入参类型） -> person.getAge()（返回值类型）
Function function3 = person -> person.getAge();
myPrint(bravo, function3);
}
public static void myPrint(Person person, Function mapper) {
System.out.println(mapper.apply(person));
}
} 目前为止应该还蛮好理解的。
之前我们在MyList中写了个filter()方法并用Predicate接口占了坑，它接收一个“过滤器”来过滤元素。而现在，map()方法用Function接口占坑，它需要接收一个“转换器”来帮元素“变身”：
class MyList {
private List list = new ArrayList<>();
public boolean add(T t) {
return list.add(t);
}
/**
* 把MyList中的List转为List
* 不要关注Function接口本身，而应该关注apply()
* apply()接收T t，返回R t。具体实现需要我们从外面传入，这里只是占个坑
*
* @param mapper
* @param
* @return
*/
public List map(Function mapper) {
List mappedList = new ArrayList<>();
for (T t : list) {
// mapper通过apply()方法把T t 变成 R t，然后加入到新的list中
mappedList.add(mapper.apply(t));
}
return mappedList;
}
} 
传入Lambda，把坑填上
无论filter(Predicate predicate)还是map(Function mapper)，其实就是接口占坑、Lambda填坑的过程，其中函数式接口只有唯一方法，所以可以直接把接口多态看做方法多态。比如Predicate只有一个抽象方法boolean test()，那么你写一个符合的具体实现即可：一个入参，返回值为boolean。
以后但凡遇到函数式接口占坑的，只要关注入参和出参即可：
Person ==> {坑} ==> boolean
很明显，入参是Person，出参是Integer。那Person类型怎么变成Integer类型呢？填坑的方案并不唯一，你可以编写任意逻辑，比如：
Person ==> {person -> person.getAge()} ==> Integer
当然，你也可以传递person.getAge()+1。总之，坑已经占好了，注意一下入参和出参满足条件即可。
相信经过本次分析，大家已经能自己写出山寨Stream API了。
作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO
进群，大家一起学习，一起进步，一起对抗互联网寒冬