标签：07 Person list List String new public 表达式 Lambda

泛型

泛型（Generics）是JDK1.5版本增加的技术，他可以帮助我们建立类型安全的集合。在使用了泛型的集合中，不必进行强制类型转换。JDK提供了支持泛型的编译器，将运行时的类型检查提前到了编译时执行，使代码可读性和安全性更高。

不使用泛型：

public static void main(String[] args) {
        List myList = new ArrayList();
        //准备对象
        Cat c = new Cat();
        Bird b = new Bird();
        
        myList.add(c);
        myList.add(b);
        
        //遍历集合，调用特有方法
        Iterator iterator = myList.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            if (obj instanceof Cat){
                ((Cat) obj).catchMouse();
            }else {
                ((Bird)obj).flying();
            }
        }
    }

在JDK1.5版本之前，我们通过Object类型来实现参数的“任意化”，但是“任意化”带来的代价是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

可以使用泛型 List<Animal> 指定集合中的数据类型只允许存储Animal类型的数据

泛型使得集合中的数据更加统一了

在迭代器获取元素的时候也可以使用泛型：

因为在声明集合的时候使用了泛型：

而迭代器中的泛型和集合相同：

这样获取到的就是声明集合时指定的元素类型。

获取到的就是Animal类型的对象，因为我们想要求这个类只能对某些类型的数据进行操作，add/get方法都限制了只能对这些类型的数据进行操作

public static void main(String[] args) {
       	List<Animal> myList = new ArrayList<Animal>();
        myList.add(new Bird());
        myList.add(new Cat());

        Iterator<Animal> iterator = myList.iterator();

        while (iterator.hasNext()){
            Animal animal = iterator.next();
            animal.move();
        }
    }

泛型机制只在程序编译阶段起作用，运行阶段不起作用

集合中存储的元素类型统一了
集合中取出的元素类型是泛型指定的类型，不需要进行大量的向下转型

缺点：导致集合中存储的元素缺乏多样性？

自动类型推断机制

JDK7.0 新特性，又称为钻石表达式

public static void main(String[] args) {
    //new ArrayList<>() 尖括号中内容可以省略
    ArrayList<Animal> myList = new ArrayList<>();
    
    //遍历
    Iterator<Animal> iterator = myList.iterator();
    while(iterator.hasNext()){
        Animal a = iterator.next();
        a.move();
    }
}

规定泛型使用 String ，方法的参数就只能是String

public class GenericTest03 <标识符随便写> {
    public static void main(String[] args) {
        GenericTest03<String> gt = new GenericTest03<>();
        
        
        gt.doSome(); //此处只能是String
    }

    public void doSome(标识符随便写 a){
        System.out.println(a);
    }
}

示例：

public interface Iterator<E>

假如规定ArrayList中存储的是Animal类型，其中Itr内部类的Iterator接口同时被指定该类型，next()返回的结果就是Animal类型：

E next();

有类定义如下：

class MyIterator<T>{
    public T get(){
        return null;
    }
}

如果写了泛型没有使用：

该类的泛型就被替换为Object

泛型擦除

Java中的泛型是伪泛型，例如定义:ArrayList<String>，编译器只在添加元素时检查是不是String类型的数据，在集合中还是看作Object类型，并且在获取的时候会将Object类型的数据强转为String类型

Java源文件：

ArrayList<String> list = new ArrayList();

编译为class文件：

ArrayList list = new ArrayList();

这就叫做泛型的擦除。

注意：泛型不能写基本数据类型，因为集合中存储的所有元素都看作Object，而基本数据类型是不能转换为Object的，只能写包装类

可以使用反射绕过编译器的检查：

public class GenericClassDemo {

    public static void main(String[] args) throws Exception {

        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        // 编译器会阻止
        // list.add(333);

        // 但泛型约束只存在于编译期，底层仍是Object，所以运行期可以往List存入任何类型的元素
        Method addMethod = list.getClass().getDeclaredMethod("add", Object.class);
        addMethod.invoke(list, 333);

        // 打印输出观察是否成功存入Integer（注意用Object接收）
        for (Object obj : list) {
            System.out.println(obj);
        }
	    //但是get该元素就会ClassCastException
    }
}

泛型的擦除与补偿

泛型的出现提高了编译时的安全性，正因为编译时对添加的数据做了检查，则程序运行时才不会抛出类型转换异常。因此泛型本质上是编译时期的技术，是专门给编译器用的。

加载类的时候，会将泛型擦除掉（擦除之后的类型为Object类型），这个称为泛型擦除。

为什么要有泛型擦除呢？其本质是为了让JDK1.4和JDK1.5能够兼容同一个类加载器。在JDK1.5版本中，程序编译时期会对集合添加的元素进行安全检查，如果检查完是安全的、没有错误的，那么就意味着添加的元素都属于同一种数据类型，则加载类时就可以把这个泛型擦除掉，将泛型擦除后的类型就是Object类，这样擦除之后的代码就与JDK1.4的代码一致。

因为加载类的时候，会默认将类中的泛型擦除为Object类型，所以添加的元素就被转化为Object类型，同时取出的元素也默认为Object类型。而我们获得集合中的元素时，按理说取出的元素应该是Object类型，为什么取出的元素却是实际添加的元素类型呢？

这里又做了一个默认的操作，我们称之为泛型补偿。在程序运行时，通过获取元素时指定的实际类型进行强转，这就叫做泛型补偿（不必手动实现强制转换）。获得集合中的元素时，虚拟机会根据获得元素的实际类型进行向下转型，也就是会恢复获得元素的实际类型，因此我们就无需手动执行向下转型操作，从本质上避免了抛出类型转换异常。

如果获取元素时指定的实际类型是Object，就不需要转型了

泛型类

当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类。

public class Test<E>{
    E e;
}

实现ArrarList的add和get方法：

class MyArrayList<E>{  
    Object[] objs = new Object[10];  
    int size;  
  
    public boolean add(E e){  
        /* if (size == objs.length)  
            objs = grow(); */        objs[size++] = e;  
        return true;  
    }  
    public E get(int index){  
        return (E) objs[index];  
    }  
}

add方法要求只能存入指定泛型的元素，所以参数是E

ArrayList的get方法：

从集合中拿出元素的时候也要转换为泛型对应的类型

验证了：泛型只在向集合中存或从集合中取时有效，在集合内部还是将元素看作Object类型

泛型方法

方法中形参类型不确定时，可以使用类名后面定义的泛型。

如果一个类中只有一个方法的形参类型不确定，可以在方法申明上定义自己的泛型

格式：

public <T> void show(T t){}

[修饰符列表] <类型> 返回值类型 方法名(类型 变量名){}

在调用该方法时，T的类型才确定

练习：定义一个工具类：ListUtil，类中定义一个静态方法addAll，用来向指定集合中添加多个元素。

public class Generic_test {  
    public static void main(String[] args) {  
        ArrayList<Animal> animals = new ArrayList<>();  
        animals.add(new Cat());  
        animals.add(new Dog());  
        ListUtils.addAll(animals,new Cat(),new Dog(),new Object());  
        System.out.println(animals);  
        Animal animal = animals.get(animals.size() - 1);  
		System.out.println(animal); //ClassCastException
    }  
}  
class ListUtils{  
    public static void addAll(List list,Object ... objs){  
        for (int i = 0; i < objs.length; i++) {  
            list.add(objs[i]); //编译完成后，add方法的参数被替换为Animal，为什么obj可以赋值给Animal？
        }  
    }  
}

为什么能存入？

这样做是不行的，获取到在第8行获取animal时，编译器认为取出的是Animal类型，但是实际上取出的是Object类型，ListUtils中addAll方法未对泛型进行限制，应该根据List的泛型来要求只能存入对应类型的元素

class ListUtils{  
    public static <E> void addAll(List<E> list,E ... es){  
        for (int i = 0; i < es.length; i++) {  
            list.add(es[i]);  
        }  
    }  
}

方法调用时，泛型的类型，也就是参数的类型就被确定了

泛型接口

修饰符 interface 接口名<类型>{
    
}
public interface List<E>{
    
}

使用带有泛型的接口：

实现类给出具体类型

实现类延续泛型，创建对象时再确定具体的类型

泛型的继承和通配符

泛型不具备继承性，但是数据具备继承性

method方法指明了参数是 ArrayList<Animal>，但是ArrayList<Cat>不是它的子类，只有ArrayList 的子类可以传入，并且泛型要和指定泛型相同

假设有ArrayList的子类SubArrayList：

class SubArrayList extends ArrayList{  
  
}

就可以传入这样的方法：

并不会报错：

练习：定义方法，形参是一个集合，集合中的数据类型不确定

    public static <E> void method(ArrayList<E> list){

    }

但是这样写有一个弊端，传递进去的可以是Animal、Car、Student等任意类型的数据

如果要求只能传递Animal及其子类，可以使用泛型的通配符

泛型的通配符：?表示不确定的类型，但是可以进行类型的限定：

? extends E：表示可以传递E或者E所有的子类类型
? super E：表示可以传递E或者E所有的父类类型

注意：使用通配符不需要在方法的修饰符后再次声明

    public static void method(ArrayList<? extends Animal> list){

    }

表示现在的method方法中ArrayList的类型只能是Animal及其子类

    public static void method(ArrayList<? super Animal> list){

    }

表示现在的method方法中ArrayList的类型只能是Animal及其父类（Object）

应用场景：

如果在定义类、方法、接口时，如果类型不确定，就可以定义泛型类、泛型方法、泛型接口。
如果类型不确定，但知道只能传递某个继承体系中的类型，就可以使用泛型的通配符

关键点：可以限定类型的范围。

泛型思考

上：特定化与泛型

在JDK1.5引入泛型之前，ArrayList采取的方式是：在内部塞入一个Object[] array。

public class ArrayList {
    private Object[] array;
    private int size;
    public void add(Object e) {...}
    public void remove(int index) {...}
    public Object get(int index) {...}
}

如果用JDK1.5以前的ArrayList存储String类型，那么会有以下两个缺点（其实是问题的一体两面）：

需要强制转型
强制转型容易出错

例如，代码必须这么写：

ArrayList list = new ArrayList();
list.add("Hello");
// 获取到Object，必须强制转型为String:
String first = (String) list.get(0);

为什么要强制转型？因为String是真正的类型，转型后才能使用String特有的方法，比如replace()。

OK，在确认必须强转的前提下，我们继续讨论。

强转会带来一个问题：很容易出现ClassCastException。

// JDK1.4可以这样做
list.add(new Integer(123));
// ERROR: ClassCastException:
String second = (String) list.get(1);

作为一种解决方法，JDK1.5之前的程序员可以为String类型单独编写一种ArrayList：

public class StringArrayList {
    // 因为这种ArrayList只存String，所以不需要用Object[]兼容所有类型，只要String[]即可
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

这样一来，存入和取出都被限定为String，且不需要强制转型，因为编译器会强制检查放入的类型：

StringArrayList list = new StringArrayList();
list.add("Hello");
String first = list.get(0);
// 编译错误: 不允许放入非String类型:
list.add(new Integer(123));

问题暂时解决。

然而，新的问题是，如果要存储Integer，还需要为Integer单独编写一种ArrayList：

public class IntegerArrayList {
    private Integer[] array;
    private int size;
    public void add(Integer e) {...}
    public void remove(int index) {...}
    public Integer get(int index) {...}
}

如果还有其他类型，就要编写各种各样特定类型的ArrayList：

LongArrayList
DoubleArrayList
PersonArrayList
...

这是不可能的，光JDK的class就有成千上万个，而且还不算普通Java用户编写的类。

为了解决新的问题，我们必须把ArrayList变成一种模板。

什么是模板呢？以设计模式中的模板方法模式为例：

/**
 * 验证码发送器
 *
 * @author qiyu
 * @date 2020-09-08 19:38
 */
public abstract class AbstractValidateCodeSender {

    /**
     * 生成并发送验证码
     */
    public void sendValidateCode() {
        // 1.生成验证码
        String code = generateValidateCode();

        // 2.把验证码存入Session
        // ....

        // 3.发送验证码
        sendCode();
    }

    /**
     * 具体发送逻辑，留给子类实现：发送邮件、或发送短信都行
     */
    protected abstract void sendCode();

    /**
     * 生成验证码
     *
     * @return
     */
    public String generateValidateCode() {
        return "123456";
    }

}

对于上面的模板，我们可以有多种实现方式：

/**
 * 短信验证码发送
 *
 * @author qiyu
 * @date 2020-09-08 19:44
 */
public class SmsValidateCodeSender extends AbstractValidateCodeSender {

    @Override
    protected void sendCode() {
        // 通过阿里云短信发送
    }
}

/**
 * QQ邮箱验证码发送
 *
 * @author qiyu
 * @date 2020-09-08 19:45
 */
public class EmailValidateCodeSender extends AbstractValidateCodeSender {

    @Override
    protected void sendCode() {
        // 通过QQ邮箱发送
    }
}

所谓模板，就是“我能做的都给你做了，少量易变动的东西我留出来，你自己DIY去”。

同理，ArrayList<T>也是一种模板，能写的方法都给你写了，但变量类型我定不了，于是抽成类型参数:

public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class类型，反正我已经帮你参数化了，你自己定。

这样一来，我们就实现了：只需编写一次模版，可以创建任意类型的ArrayList：

// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<>();

因此，泛型类就是一种模板类，例如ArrayList<T>，然后使用者可以自己选择将模板填充为什么类型：

// 嘿嘿，我想把ArrayList<T>填充为ArrayList<String>，专门收纳String类型
ArrayList<String> strList = new ArrayList<>();

你可以理解为此时ArrayList内部自动被赋值成这样（编译器层面）：

public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

由编译器针对类型作检查：

strList.add("hello"); // OK
String s = strList.get(0); // OK，因为上面add()保证了只能添加String类型，所以无需强制转型
strList.add(new Integer(123)); // compile error!
Integer n = strList.get(0); // compile error!

这样一来，既实现了编写一次万能匹配，又能通过编译器保证类型安全：这就是泛型。

形式类型参数、实际类型参数

泛型是一种技术，而不是单指ArrayList<T>中的T。像ArrayList<T>的T，Map<K, V>中K和V，统称类型参数(Type Parameter)，也叫形式类型参数，它只是泛型这个技术的组成部分。

使用泛型时，比如ArrayList<String>，T被替换为String，可以看做是对T的“赋值”，这里的String称为实际类型参数(actual type parameter)。

实际类型参数用来为形式类型参数赋值，把 ArrayList<T> 由泛化通用的模板变为特定类型的类。可以把泛型理解为：变量是对数据的抽取，泛型是对变量类型的抽取，抽取成类型参数，抽象层次更高。

举个例子，当你看到同事A写了以下代码：

// 获取教师列表
public List<User> listTeachers() {
    return jdbcTemplate.execute("select * from t_user where user_type=1");
}

// 获取学生列表
public List<User> listStudents() {
    return jdbcTemplate.execute("select * from t_user where user_type=2");
}

你肯定会下意识地建议他：哦，我的天哪，你应该把userType提取为方法参数：

public List<User> listUser(Integer userType) {
    return jdbcTemplate.execute("select * from t_user where user_type=" + userType);
}

从某种程度来说，把SQL中的user_type=1、user_type=2提升为方法入参，就是为了通用性，解决了硬编码（hard code）问题。但在绝大部分初学者的认知里，对于：

他们往往只能达到以下层次：

private Integer value
private String value

对于Java这种语言来说，一个变量其实应该至少包含两部分（访问权限暂不讨论）：

变量类型
变量值

大部分人只能想到抽取变量值，无法达到抽取变量类型的层次。那怎么才能达到抽取变量类型的层次呢？或者说，什么场景下需要抽取变量类型呢？

假设你有一天你发现同事A又在写bug：

public final class MapUtil {
    // 私有构造
    private MapUtil() { }

    // 把userList转为userMap
    public static Map<Long, User> listToMap(List<User> list) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyMap();
        }
        Map<Long, User> userMap = Maps.newHashMap();
        for (User user : list) {
            userMap.put(user.getId, user);
        }
        return userMap;
    }

    // 把departmentList转为departmentMap
    public static Map<Long, Department> listToMap(List<Department> list) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyMap();
        }
        Map<Long, Department> departmentMap = Maps.newHashMap();
        for (Department department : list) {
            departmentMap.put(department.getId, department);
        }
        return departmentMap;
    }
}

你看到上面的代码，又开始阴阳怪气地说：哦，我的天哪，你应该...

“闭上你的嘴，我TMD知道要用泛型！”，同事A愤怒地骂道。只见他在你面前飞快地重构MapUtil：

public final class MapUtil {
    private MapUtil() { }

    public static <V, K> Map<K, V> listToMap(List<V> list, Function<V, K> keyExtractor) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyMap();
        }
        Map<K, V> res = Maps.newHashMap();
        for (V v : list) {
            K k = keyExtractor.apply(v);
            if (k == null) {
                continue;
            }
            res.put(k, v);
        }
        return res;
    }
}

重构后的代码，和原先的两个方法在结构上几乎一模一样（忽略keyExractor这个函数式接口），只是变量类型换成了类型参数，即“对变量类型进行抽取”（所以在泛型里，List<T>中的T叫类型参数），而代码也更加通用了。

把变量类型抽取成类型参数T构造出模板代码，再通过实际类型参数赋值（比如ArrayList<T>变成ArrayList<User>），把类型特定化，最后配合编译器在编译期对相关操作的变量类型进行约束，这就是泛型。

抽取变量，我们早就习以为常，但抽取变量类型，却从未听说。这也是初学者觉得泛型抽象的根本原因

泛型是对引用类型的抽取，基本类型是无法抽取的

ArrayList与泛型

泛型是实现模板代码的一种手段

文章中经过一次次演化，我们的ArrayList最终变成了这样：

public class ArrayList<T> {
    private T[] array; // 我们以为ArrayList<T>内部会有个T[] array
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

但泛型数组其实是非常特殊的，Java并不能直接实现泛型数组。ArrayList内部实际上仍然沿用了之前的Object[]。

那么，ArrayList为什么还能进行类型约束和自动类型转换呢？

下：泛型实现机制

要回答这个问题，我们必须了解Java的两个阶段：编译期、运行期。你可以理解为Java代码运行有4个要素：

源代码
编译器
字节码
虚拟机

也就是说，Java有两台很重要的机器，编译器和虚拟机。

在代码编写阶段，我们确实引入了泛型对变量类型进行泛化抽取，让类型是不特定的（不特定的即通用的），从而创造了通用的代码模板，比如ArrayList<T>：

public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

模板定好后，如果我们希望这个ArrayList只处理String类型，就传入类型参数，把T“赋值为”String，比如ArrayList<String>，此时你可以理解为代码变成了这样：

public class ArrayList<String> {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

所以add(1)会编译报错。

但事实真的如此吗？

我们必须去了解泛型的底层机制。

泛型擦除与自动类型转换

我们来研究以下代码：

public class GenericDemo {

    public static void main(String[] args) {
        UserDao userDao = new UserDao();
        User user = userDao.get(new User());
        List<User> list = userDao.getList(new User());
    }

}

class BaseDao<T> {

    public T get(T t){
        return t;
    }

    public List<T> getList(T t){
        return new ArrayList<>();
    }
}


class UserDao extends BaseDao<User> {

}

class User{

}

编译得到字节码：

通过反编译工具，反编译字节码：

public class GenericDemo {
	// 编译器会为我们自动加上无参构造器
    public GenericDemo() {}

    public static void main(String args[]) {
        UserDao userDao = new UserDao();
        /**
         * 1.原先代码是 User user = userDao.get(new User());
         *   编译器加上了(User)，做了类型强转
         */
        User user = (User)userDao.get(new User());
        /**
         * 2.List<User>的泛型被擦除了，只剩下List
         */
        java.util.List list = userDao.getList(new User());
    }
}

class BaseDao {

    BaseDao() {}
    
	// 编译器编译后的字节码中，其实是没有泛型的，泛型T底层其实是Object
    public Object get(Object t) {
        return t;
    }

    public List getList(Object t) {
        return new ArrayList();
    }
}

// BaseDao<User>泛型也没了
class UserDao extends BaseDao {
    UserDao(){}
}

class User {
    User() {}
}

反编译后我们很容易发现，其实所谓的泛型T在编译后就会消失，底层其实还是Object。既然泛型底层用Object接收，那么：

对于ArrayList<String>，为什么add(Integer i)会编译报错？
对于ArrayList<String>，list.get(0)为什么不需要强制转型？

因为泛型本身是一种编译时的机制，是Java程序员和编译器之间的协议。

ArrayList<T>是已经编写好的代码模板，底层还是Object[]接收元素，但我们可以通过ArrayList<String>的语法形式，告诉编译器：“我希望你把这个ArrayList看做StringArrayList”。

换句话说，编译器会根据我们指定的实际类型参数（ArrayList<String>中的String），自动地在编译器做好语法约束：

ArrayList<String>的add(E e)只能传String类型
ArrayList<String>的get(i)返回值一定是String（转换为和泛型相同的类型时编译后自动强转，无需我们操心）

在使用泛型作为参数的方法中，编译器强制要求该方法只能传入该类型的实现类；在使用泛型作为返回值的方法中，编译器会自动的转型

此时我们就可以解释前文中的问题：

练习：定义一个工具类：ListUtil，类中定义一个静态方法addAll，用来向指定集合中添加多个元素。

public class Generic_test {  
    public static void main(String[] args) {  
        ArrayList<Animal> animals = new ArrayList<>();  
        animals.add(new Cat());  
        animals.add(new Dog());  
        ListUtils.addAll(animals,new Cat(),new Dog(),new Object());  
        System.out.println(animals);  
        Animal animal = animals.get(animals.size() - 1);  ////ClassCastException
		System.out.println(animal); 
    }  
}  
class ListUtils{  
    public static void addAll(List list,Object ... objs){  
        for (int i = 0; i < objs.length; i++) {  
            list.add(objs[i]); //编译完成后，add方法的参数被替换为Animal，为什么obj可以赋值给Animal？
        }  
    }  
}

为什么能存入？

因为泛型实际上被擦除了，add(E e) 还是add(Object e) ，并不是我们所认为的add(String) ，在取出的时候，如果这样获取元素：

        Animal animal = animals.get(animals.size() - 1);  ////ClassCastException
		System.out.println(animal);

出错的原因是，这行代码其实被翻译为：

		Animal animal = (Animal)animals.get(animals.size() - 1);  ////ClassCastException
		System.out.println(animal);

这样一定会出错的，因为该位置的元素实际上是Object类型，但如果换一种方式：

        Object animal = animals.get(animals.size() - 1); 
		System.out.println(animal);

反编译：

        Object animal = animals.get(animals.size() - 1); 
		System.out.println(animal);

没有进行强制类型转换，自然也没有异常了。

基于上面的实验，我们可以得到以下4个结论：

泛型是JDK专门为编译器创造的语法糖，只在编译期，由编译器负责解析，虚拟机不知情
存入：普通类继承泛型类并给变量类型T赋值后，就能强制让编译器帮忙进行类型校验

取出：代码编译时，编译器底层会根据实际类型参数自动进行类型转换，无需程序员在外部手动强转

实际上，编译后的Class文件还是JDK1.5以前的样子，虚拟机看到的仍然是Object

ArrayList本身并没有任何改变，只是引入了外部的力量，这个力量能够对一些行为进行约束。换言之，Java在编译期引入了泛型检测机制，对容器的使用进行了强制约束，但容器本身并没有发生实质性的改变。

如何利用反射绕过编译器对泛型的检查：

public class GenericClassDemo {

    public static void main(String[] args) throws Exception {

        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        // 编译器会阻止
        // list.add(333);

        // 但泛型约束只存在于编译期，底层仍是Object，所以运行期可以往List存入任何类型的元素
        Method addMethod = list.getClass().getDeclaredMethod("add", Object.class);
        addMethod.invoke(list, 333);

        // 打印输出观察是否成功存入Integer（注意用Object接收）
        for (Object obj : list) {
            System.out.println(obj);
        }
    }
}

泛型与多态

经过上面的介绍，大家开始慢慢觉得泛型只和编译器有关，但实际上泛型的成功离不开多态。

上一篇我们已经解释了为什么需要代码模板（通用），现在我们来聊聊为什么能实现代码模板。

代码模板的定义是，整个类框架都搭建好了，只是不确定操作什么类型的对象（变量）。但它必须做到：无论你传什么类型，模板都能接收。

泛型固然强悍，既能约束入参，又能对返回值进行自动转换。但大家有没有想过，对于编译器的“智能转换”，其实是需要多态支持的。如果Java本身不支持多态，那么即使语法层面做的再好，无法利用多态接收和强转都是白搭。

所以代码模板的本质就是：用Object接收一切对象，用泛型+编译器限定特定对象，用多态支持类型强转。

大家拷贝下方代码本地运行一下：

/**
 * @author qiyu
 * @date 2020-09-09 00:02
 */
public class ObjectArray {
    public static void main(String[] args) {
        // objects其实就是对应ArrayList内部的Object[]
        Object[] objects = new Object[4];
        
        // 引入泛型后的两个作用：

        // 1.入参约束：如果是ArrayList，那么入参约束会在一开始就确定，而下面的objects就惨多了，Integer/String都可以随意出入
        objects[0] = 1;
        objects[1] = 2;
        objects[2] = "3";
        objects[3] = "4";

        // 2.自动类型转换：如果是ArrayList，由于入参已经被约束，那么返回值类型也随之确定，编译器会帮我们自动转换，无需显式地手动强转
        Integer zero = (Integer) objects[0];
        Integer one = (Integer) objects[1];
        String two = (String) objects[2];
        String three = (String) objects[3];

        System.out.println(zero + " " + one + " " + two + " " + three);

    }
}

上面的代码是对泛型底层运作的模拟。

当泛型完成了“编译时检查”和“编译时自动类型转换”的作用后，底层还是要多态来支持。

你可以理解为泛型有以下作用：

抽取代码模板：代码复用并且可以通过指定类型参数与编译器达成约定

类型校验：编译时阻止不匹配元素进入Object[]

类型强转：根据泛型自动强转（多态，向下转型）

但实际运行时，Object[]接收特定类型的元素，体现了多态，取出Object[]元素并强转，也体现了多态。

如果一段代码注定要报错，那么应该尽量提前到编译期，而且编译器自动转型比手动转型安全得多。

所以，泛型只是程序员和编译器的约定，程序员告诉编译器，我假定这个List只能存String，你帮我盯着点。对于存入的方法，如果不小心放错类型，就编译报错提醒我。对于取出的方法，编译时你根据我给的实际类型参数自动帮我类型转换。

泛型：其实一切都是确定的

对于初学者来说，他们惧怕泛型是因为泛型给人一种不确定的感觉。我们一起再来看看文章开头的问题：

但是在Java中，只有多态是不确定的。

泛型真的把对象类型弄成了变量吗

并没有，通过反编译大家也看到了，其实根本没有所谓的泛型类型T，底层还是Object，所以当我们new一个ArrayList时，JVM根本不会傻傻等着T被确定。T作为参数类型，只作用于编译阶段，用来限制存入和强转取出，JVM是感知不到的，它不关心这个对象将来是ArrayList<Integer>还是ArrayList<String>，仍然还是按JDK1.4以前的做法，底层准备好Object[]，以便利用多态特性接收任意类型的对象。

更何况JVM实际new对象是在运行期，编译期的小把戏和它有什么关系？

所以对于泛型类本身来说，它的类型是确定的，就是Object或Object[]数组。

只是在用到泛型的地方，编译器会帮你进行存取的限制

在编译之后，类型参数T就是确定的

对象类型不确定导致JVM无法创建对象？

如果你指的是泛型类内部的对象类型，上面已经解释了，它的类型是确定的，就是Object或Object[]数组。

如果你指的是存入的元素类型，这个就更荒谬了：

List<User> list = new ArrayList<>();

list.add(new User());

我就是踏踏实实new了一个User对象，怎么会是不确定的呢？

所以泛型有什么是不确定的吗？没有。

实在要说的话，泛型的不确定性在于程序员要求编译器检查的类型是不确定的：

ArrayList<Integer>：嘿，编译器，帮我把元素限制为Integer类型
ArrayList<String>：嘿，编译器，帮我把元素限制为String类型
...

大家可以暂时把Java的运行环境理解为一颗双层巧克力球，第一层是编译器，第二层是JVM，泛型可以暂时简单理解为一种约束性过滤，但JVM本身在JDK1.5前后是没有太大区别。

泛型是对变量类型的抽取，从而让变量类型变成一种参数（type parameter），最终得到通用的代码模板，但这种所谓的类型不确定，只是为了方便套用各种对象类型进行语法校验，都是编译期的。

而编译期的不确定并不影响运行期对象的创建，因为容器的对象类型始终是Object，元素的类型是用户自己指定的，比如new User()，也是确定的。

一点补充

Oracle官方文档解释了为什么要用泛型，但没解释为什么不支持基本类型：

Why Use Generics?

JDK1.0开始就有基本数据类型和引用类型，直到JDK1.5才引入泛型。而引用类型存在多态，基本数据类型没有多态，因为多态是面向对象的特征。

多态极大地扩展了Java的可玩性，但也有一些弊端。还是以ArrayList为例：

ArrayList是JDK1.2出来的，那会儿还没有泛型，而ArrayList想什么都能存，于是内部用的是Object[]。一个Object[]存了具体类型的元素，本身就构成多态，那么取出时就会面临类型强转的问题（不转就用不了实际类型的很多方法）。

存进去时Object obj = new User()，取出来没记住，转成(Cat)obj了，就强转异常了，于是JDK1.5引入了泛型，在编译期进行约束并帮我们自动强转。

可以说，本身泛型的引入就是为了解决引用类型强转易出错的问题，也就自然不会去考虑基本类型。

当然，网上也有这样解释的，说JDK1.5不仅引入泛型，还同时发布自动拆装箱特性，所以int完全可以用Integer代替，也就无需支持int。

大家猜猜Integer、Long这些包装类啥时候出来的？是不是和我一样以为是JDK1.5出来的？

其实即使本身JDK1.5没有引入自动拆装箱，用Integer这些包装类也能勉强糊弄事，手动把基本类型包装后丢进去就好了。

但是大家有没有想过，JDK1.5发布泛型的同时为什么还发布了自动拆装箱特性？虽然真实原因已经无法考究，但我猜测自动拆装箱引入的目的有两个：

简化代码
从某种意义上让泛型支持基本类型

泛型是依赖编译器+泛型擦除实现的，它底层还是用Object去接收各类数据。即使编译器在语法上让ArrayList<int>过去了，泛型擦除后int可就要被Object接收了。

所以问题就变成了，Java能不能做到

Object obj = 666;

很显然，不能。引入了自动拆装箱后还真能！

所以JDK1.5以后，只要你敢把基本类型数据赋值给引用类型，JDK就毫不留情地帮你转成包装类，到头来还是引用类型。

从这个层面来讲，JDK1.5以后基本类型也“变成了”引用类型（基本运算除外），泛型写成ArrayList<int>还是ArrayList<Integer>已经没有什么差别，甚至从语义上来讲ArrayList<Integer>似乎比ArrayList<int>更自洽，坚持了“泛型是对引用类型变量的抽取”这一信条。

我个人观点是，Java已经尽自己最大的努力让泛型支持基本类型了。只不过它不是从语法上支持，而是从功能上支持。拒绝ArrayList<int>保证语义自洽的同时，通过list.add(1)配合自动拆装箱新特性，从功能上实现对基本类型的支持。

但归根结底，Java泛型之所以无法支持基本类型，还是因为存在泛型擦除，底层仍是Object，而基本类型无法直接赋值给Object类型，导致JDK只能用自动拆装箱特性来弥补，而自动拆装箱会带来性能损耗。

只能说JDK也是不得已而为之吧。

Java 不能实现真正泛型的原因是什么

泛型边界

之前讲述了泛型是什么以及有什么用：

作用于编译期，由编译器解析，是一种兼具类型约束和自动转型的代码模板
存入：约束存入的元素类型，将可能的类型错误提前到编译期
取出：编译自动转型，消除手动强转，极大降低ClassCastException的风险

泛型只是程序员和编译器的约定。

我们可以通过泛型告诉编译器自己的意图：

我现在假定这个List只能存String，你帮我盯着点，后面如果不小心放错类型，在编译期报错提醒我。

当然，要想编译器帮我们约束类型，就必须按人家的规矩办事。就好比Spring明明告诉你默认读取resources/application.yml，你非要把配置文件命名为resources/config.yml当然就报错啦。

而泛型也有一套自己的规则，我们必须遵守这些规则才能让编译器按我们的意愿做出约束。

今天我们来学习泛型通配符。

在讲述通配符的语法规则时，我会尽量给出自己的理解，让大家更容易接受它们。另外需要说明的是，在泛型相关的文章里我们总是以List元素存入、取出举例子，是因为容器类是我们接触最多的，这样更好理解。实际上对于泛型类、泛型方法都是适用的，并不一定要是容器类。

简单泛型

JDK1.5以后，我们全面跨入泛型时代。

假设现在有一个需求：设计一个print方法打印任意类型的List。

你想显摆一下刚学的泛型，于是这样设计：

public class GenericClassDemo {

    public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        print(integerList);
    }

    public static void print(List<Integer> list) {
		// 打印...
    }
}

需求是打印任意类型的List。目前的print()只能接收List<Integer>，你传List<String>会报错：

你想了想，Object是所有对象的父类，我改成List<Object>吧：

这下连List<Integer>都不行了。这是为什么呢？我们来分析一下原因。

实际编码时，常见的错误写法如下：

// 错误写法1：间接传递（通常发生在方法传参，比如将stringList传给print(List<Object> list)）
List<String> stringList = new ArrayList<>();
List<Object> list = stringList;
// 错误写法2：直接赋值
List<Object> list = new ArrayList<String>();

list引用和实际指向的List容器类型必须一致（赋值操作左右两边的类型必须一致）。

JDK推荐的写法：

// 比较啰嗦的写法
List<String> list = new ArrayList<String>();
List<Object> list = new ArrayList<Object>();
// 省略写法，默认左右类型一致
List<String> list = new ArrayList<>();
List<Object> list = new ArrayList<>();

我们在前面已经了解到，泛型底层其实还是Object/Object[]，所以上面的几种写法归根到底都是Object[]赋值给Object[]，理论上是没有问题的。

那么我们不禁要问：既然底层都支持了，为什么编译器要禁止这种写法呢？

正向思考

首先，Object和String之间确实有继承关系，但List<Object>和List<String>没有，不能用多态的思维考虑这个问题（List和ArrayList才是继承/实现关系）

List<Object> list = new ArrayList<String>();

其次，讨论泛型时，大家应该尽量从语法角度分析。

左边List<Object>的意思是希望编译器帮它约束存入的元素类型为Object，而右边new ArrayList<String>()则希望约束存入的类型为String，此时就会出现两个约束标准，而它们却是对同一个List的约束，是自相矛盾的。

反向思考

如果上面的论述还是缺乏说服力，那么我们干脆假设List<Object> list = new ArrayList<String>()是合法的

先来看看数组是怎么处理类似问题的：

数组底层和泛型不同，泛型底层都是Object[]/Object[]，而数组是真的分别创建了Object[]和String[]，而且允许String[]赋值给Object[]。但这是它的弱点，给了异常可趁之机：

public static void main(String[] args) throws Exception {
    // 直接往String[]存Integer会编译错误
    String[] strings = new String[3];
    strings[0] = "a";
    strings[1] = "b";
    strings[2] = 100; // COMPILE ERROR!

    // 但数组允许String[]赋值给Object[]
    Object[] objects = strings;
    // 这样就能通过编译了，但运行期会抛异常：ArrayStoreException
    objects[2] = 100;
}

数组允许String[]赋值给Object[]，但却把错误被拖到了运行期，不容易定位。

同样的，如果泛型也允许这样的语法，那就和数组没区别了：

首先，ls.add(new Object())成功了，那就意味着之前List<String>所做的约束都白费了，因为StringList中混入了别的类型
其次，编译器仍会按String自动转型，会发生ClassCastException

这么看来，泛型强制要求左右两边类型参数一致真是明智的举措，直接把错误扼杀在编译期。

泛型的指向和存取

在之前介绍泛型时，我们观察的维度只有存入和取出，实际上泛型还有一个很重要的约束：指向。为什么之前不提这个概念呢？因为之前接触的泛型都太简单了，比如List<String>只能指向List<String>，也就是泛型左右两边类型必须一致，没什么好讲的。

之前接触的是简单泛型，比如List<String> list = new ArrayList<String>()，左右的泛型类型必须一致

但是，观察如下代码：

List<Number> 不只可以存入Number类型的数据，可以存入任何Number的子类，对于List<Number> 来说，反正取出时会向上转型为Number类型，很安全。

至此，我们完善了泛型最重要的两个概念：指向、存取。

对于简单泛型而言：

List<Number>指向：只能指向List<Number>，左右两边泛型必须一致（所以简单泛型解决不了
print(List<???> list)的通用性问题）
List<Number>存入：可以存入Integer/Long/BigDecimal...等Number子类元素
List<Number>取出：自动按Number转（存在多态，不会报错）

后面学习通配符时，也请大家时刻保持清醒，多想想当前list可以指向什么类型的List，可以存取什么类型的元素。如果你觉得上面的推演太绕了，那么就记住：简单泛型的左右两边类型必须一致。

通配符

既然泛型强制要求左右两边类型参数必须一致，是否意味着永远无法封装一个方法打印任意类型的List？如何既能享受泛型的约束（防止出错），又能保留一定的通用性呢？

使用通配符就可以完成，我把List<T>、BaseDao<T>这样的称为简单泛型，把extends、super、?称为通配符。而简单泛型和通配符组合后又可以得到更为复杂的泛型，比如? extends T、? super T、?等。简而言之，通配符可以用来调节泛型的指向和存取之间的矛盾。

比如，有时我们需要list能指向不同类型的List（希望print()方法能接收更多类型的List）、有时我们又希望泛型能约束元素的存入和取出。但指向和存取往往不可兼得，具体要选用哪种泛型，需要根据实际情况做决定。

extends：上边界通配符

extends是上边界通配符，所以对于 List<? extends Number>，元素类型的天花板就是Number，右边List的元素类型只能比Number“低”。

List<? extends Number> list = new ArrayList<Integer>();

换句话说，List<? extends Number>只能指向List<Integer>、List<Long>等子类型List，不能指向List<Object>、List<String>。

记忆方法： List<? extends Number> list = ...，把?看做右边List的元素（暂不确定，用?代替），? extends Number表示右边元素必须是Number的子类。

你可能会问：

之前简单泛型List<Object>不能指向List<String>，怎么到了extends这就可以了。这不扯淡吗？

其实换个角度就是，Java规定简单泛型左右类型必须一致，但有些情况又要考虑通用性，所以又搞出了extends，允许List<? extends Number>指向子类型List。

之前我们假设过，如果允许简单泛型指向指向子类型List，那么存取会出问题：

现在extends通配符放宽了指向限制（List<? extends Human>允许指向List<Chinese>），是否意味着extends通配符也会发生强转错误呢？

List<String> ls = new ArrayList<>();  
List< ? extends Object> lo = ls;  
lo.add(new Object()); //出错
//java: 不兼容的类型: java.lang.Object无法转换为capture#1, 共 ? extends java.lang.Object
ls.get(0);

jdk直接强制禁止进行存储

public static void main(String[] args) {

    List<Integer> integerList = new ArrayList<>();
    integerList.add(1);

    List<Long> longList = new ArrayList<>();
    longList.add(1L);

    List<? extends Number> numberList = new ArrayList<>();
    numberList = 随机指向integerList或longList等子类型List;
    numberList.add(1);  // 由于无法确定numberList指向哪个List，所以干脆禁止add（万一指向integerList，那么add(1L)就不合适了，取出时可能转型错误）
}

再举一个例子：

对于取出的情况：

public static void main(String[] args) {

    List<Integer> integerList = new ArrayList<>();
    integerList.add(1);

    List<Long> longList = new ArrayList<>();
    longList.add(1L);

    List<? extends Number> numberList = integerList; // 不管numberList指向integerList还是longList
    Number number = numberList.get(0);  // 取出来的元素都可以转Number，因为Long/Integer都是它子类
}

看到这，我们应该有所体会：对于泛型而言，指向和存取是两个不同的方向，很难同时兼顾。要么指向放宽，存取收紧；要么指向收紧，存取放宽。

extends小结：

List<? extends Number>指向：Java允许extends指向子类型List，比如List<? extends Number>允许指向List<Integer>
List<? extends Number>存入：禁止存入（防止出错）
List<? extends Number>取出：由于指向的都是子类型List，所以按Number转肯定是正确的

相比简单泛型，extends虽然能大大提高指向的通用性，但为了防止出错，不得不禁止存入元素，也算是一种取舍。换句话说，print(List<? extends Number> list)对于传入的list只能做读操作，不能做写操作。

super：下边界通配符

super是下边界通配符，所以对于List<? super Integer>，元素类型的地板就是Integer，右边List的元素类型只能比Integer“高”。换句话说，List<? super Integer>只能指向List<Number>、List<Object>等父类型List。

记忆方法： List<? super Integer> list = ...，把?看做右边List的元素（暂不确定，用?代替），
? super Integer表示右边元素必须是Integer的父类。

super的特点是：

List<? super Integer>指向：只能指向父类型List，比如List<Number>、List<Object>
List<? super Integer>存入：只能存Integer及其子类型元素
List<? super Integer>取出：只能转Object

至此，我们发现Java同时满足了：

extends：指向子类型List
简单泛型T：指向同类型List
super：指向父类型List

说完指向问题，我们再来探讨一下存取问题。思路还是一样，既然Java允许List<? super Integer>指向List<Number>等父类型，那么如何防止存取出错呢？

假设存在class Human implement Swimming, Speaking，那么Swimming和Speaking都是Human的父类/父接口。由于List<? super Human>可以指向父类型List，要么指向SwimmingList，要么指向SpeakingList。

public static void main(String[] args) {
    List<Swimming> swimmingList = new ArrayList<>();
    // 假设加入了很多实现了Swimming接口的元素，比如Dolphin（海豚）
    // swimmingList.add(dolphin)...

    List<Speaking> speakingList = new ArrayList<>();
    // 假设加入了很多实现了Speaking接口的元素，比如Parrot（鹦鹉）
    // speakingList.add(parrot)...

    List<? super Human> humanList = swimmingList / speakingList; // 指向随机的List
    
    humanList.add(...) // 是否应该允许存入 Parrot（鹦鹉）？

}

此时对于List<? super Human>，是否应该允许加入 Parrot（鹦鹉）呢？答案是最好不要。因为humanList的指向是不确定的，如果刚好指向的是swimmingList，那么list.add(parrot)显然是不合适的。

只有存入Human及其子类才是安全的：

介绍完super的存入，最后聊聊super的取出。由于List<? super Human>可以指向任意Human父类型的List，可能是SwimmingList，也可能是SpeakingList。这意味取出的元素可能是Swimming，也可能是Speaking，是不确定的，所以用Swimming或Speaking都不太合适。

那能不能强转为Human呢？答案是不行。假设humanList指向的是swimmingList，而swimmingList里存的是Shark、Dolphin、Human，此时list.get(0)得到的是 Shark implements Swimming，强转为Human显然不合适。

?：无界通配符

允许指向任何类：

由于指向的List不确定，并且这些List没有共同的子类，所以找不到一种类型的元素，能保证add()时百分百不出错，所以禁止存入。
由于指向的List不确定，并且这些List没有共同的父类（除了Object），所以只能用Object接收。

通配符的使用场景

泛型本身比较复杂，能把简单的T用熟练的已经不多，更别说用上通配符了。但从语法本身来说，通配符就是为了让赋值更具通用性。原先泛型赋值只能是同类型之间赋值，不利于抽取通用方法。而使用通配符后，就可以在一定程度上开放赋值限制。

?是开放限度最大的，可指向任意类型List，但在对List的方法调用上也是限制最大的，具体表现在：

入参和泛型相关的都不能使用（禁止存入）
返回值和泛型相关的都只能用Object接收（只能强转为Object）

extends和super指向性各砍了一半，分别指向子类型List和父类型List，但方法使用上又相对开放了一部分：

extends不允许存入，但取出时类型稍微精确些，可以往边界类型转
super允许存入子类型元素，但取出时只能转为Object

所以如果要用到通配符，需要结合业务考虑，如果你只是希望造一个方法，接收任意类型的List，且方法内不调用List的特定方法，那就用?。而对于extends和super的取舍，《Effective Java》提出了所谓的：PECS(Producer Extends Consumer Super)

频繁往外读取内容的（向外提供内容，所以是Producer），适合用<? extends T>：extends返回值稍微精确些，对调用者友好
经常往里插入的（消耗数据，所以是Consumer），适合用<? super T>：super允许存入子类型元素

给大家举一个JDK对通配符的使用案例：

ArrayList中定义了一个addAll(Collection<? extends E> c)方法，我单独把这个方法拿出来：

class ArrayList<E> extends ... {
    
    ...

    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }
}

以Person为例，假设是List<Person> list = new ArrayList<>()，那么这个方法就变成了：

public boolean addAll(Collection<? extends Person> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

此时，addAll()只能接收Person集合或者它的Person子类的集合，比如Student extends Person：

List<Person> personList = new ArrayList<>();

List<Student> studentList = new ArrayList();
personList.addAll(studentList)

为什么会选择extends呢？还是PECS原则，因为allAll()很显然是消费者场景，我更关心对参数的具体操作，而不怎么关心返回值（就是boolean提示操作成功与否）。这也是我日常使用通配符时的一个思路，PECS确实很实用。

消费者场景下，就需要参数c去生产数据，c生产的数据都是E类型的，就可以供addAll消费

最后，很多人会以为 ? 等同于T，其实两者是有区别的。我们本质还是通过给T“赋值”来确定类型，只不过此时赋值给T的不再是某个具体的类型，而是某个“匹配规则”，帮助编译器确定向上、向下可以指向的List类型范围以及存取的元素类型限定。

总结

当你使用简单泛型时，首要考虑你想把元素规定为何种类型，顺便考虑子类型的存入是否会有影响（一般不会）。而如果要使用通配符，应该先考虑接收的范围，再考虑存取操作如何取舍（PECS原则）。

个人愚见是，通配符的出发点本来是为了解决指向问题，但开放指向后为了避免ClassCastException，不得已又对存取加了限制，实际开发时要灵活利用边界限制并结合实际需求选择合适的泛型。

泛型类

我们来回顾一下泛型类是怎么出现的。

话说JDK1.5以前，还没引入泛型时ArrayList大概是这样的：

public class ArrayList {
    private Object[] array;
    private int size;
    public void add(Object e) {...}
    public void remove(int index) {...}
    public Object get(int index) {...}
}

它有这个最大的问题是：无法限制传入的元素类型、取出时又容易发生ClassCastException。最直观的做法是使用期望类型的元素数组，比如：

public class StringArrayList {
    // 因为这种ArrayList只存String，所以不需要用Object[]兼容所有类型，只要String[]即可
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

但不可能为所有类型都编写专门的XxxArrayList，于是JDK就推出了泛型：抽取一种类模板，方法、变量都写好了，但变量的类型抽取成“形式类型参数”：

再配合编译器做约束：比如ArrayList<User>表示告诉编译器，帮我盯着点，我只存取User类型的元素。

简而言之，泛型类的出现就是为了“通用”，而且还能在编译期约束元素的类型。

泛型类的方法并不是泛型方法

以前使用Hibernate时，基本都会抽取BaseDao：

class BaseDao<T> {
    public T get(T t) {
        
    }
    
    public boolean save(T t) {
        
    }
}

方法里的T和类上的T是同一个，也正因为多个方法操作的POJO类型一致，所以才会被抽取到类上统一声明。

这个T具体是什么类型，或者说里面的get()、save()到底操作什么类型的POJO，取决于BaseDao到底被谁继承。比如：

class UserDao extends BaseDao<User> {
}

那么UserDao从BaseDao继承过来的get()、save()其实已经被约束为“只能操作User类型的元素”。

但要清楚，上面的get()、save()只是“泛型类的方法”，而不是所谓的“泛型方法”。

泛型方法

泛型类上的<T>其实是一种“声明”，如果把类型参数T也看做一种特殊的变量，那么<T>就是变量声明（不是我们一般概念中的变量声明，一个作用于运行期，一个作用于编译期）。

由于泛型类上已经声明了T，所以类中的字段、方法都可以自由使用T。但是当T被“赋值”为某种类型后，就会在编译器的帮助下形成一种强制类型约束，此时这个通用的代码模板也就不再通用了。因而你会发现，对于编译器而言UserDao extends BaseDao<User>里的方法只能操作User，CarDao extends BaseDao<Car>里的方法只能操作Car。

这好吗？一般来说，这很好，因为一个Dao操作的肯定是同一张表同一个对象，限定为某个类型反而能避免出错。但大家想想，如果不是BaseDao，而是一个工具类呢？BaseUtils提供通用的操作，
XxUtils extends BaseUtils<Xx>固然没问题，但如果XxUtils希望提供一个方法处理Yy怎么办？如果还想处理Zz呢？

比如希望提供一个工具方法，接收一个List类型参数，将List反转后输出。

问题的症结并不在于后期想要处理什么类型或者有多少种类型，而是T被过早确定了，从而早早地放弃了“可变性”。

因为对于泛型类的T来说，当UserDao继承BaseDao或者XxUtils继承BaseUtils时，T就被确定为User和Xx了，且已经拒绝了其他可能性，也就无法复用于其他类型。

那么，有没有办法延迟T的确定呢？

有，但泛型类的T已经没办法了，需要另辟蹊径，引入泛型方法。

和泛型类一样，泛型方法使用类型参数前也需要“声明”（<T>要放在返回值的前面）：

public class DemoForGenericMethod {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("1", "2", "3", "4", "5"));
        List<String> stringList = reverseList(list);
    }

    /**
     * 一个普通类，也可以定义泛型方法（比如静态泛型方法）
     * @param list
     * @param <T>
     * @return
     */
    public static <T> List<T> reverseList(List<T> list) {
        List<T> newList = new ArrayList<>();
        for (int i = list.size() - 1; i >= 0; i--) {
            newList.add(list.get(i));
        }
        return newList;
    }

}

如果不使用泛型，得到的数组get元素都是Object，如果指定了固定的泛型类型，就只能对一种类型进行操作，所以要定义为T

泛型方法中T的确定时机是使用方法时。而泛型类的确定是使用泛型类创建对象时。

泛型方法和泛型类没有必然联系，你可以理解为这两个东西可以各自使用，也可以硬把它们凑在一块，不冲突：

class BaseDao<T> {
    // 泛型类的方法
    public T get(T t) {

    }

    /**
     * 泛型方法，无返回值，所以是void。<E>出现在返回值前，表示声明E变量
     * @param e
     * @param <E>
     */
    public <E> void methodWithoutReturn(E e) {
        
    }

    /**
     * 泛型方法，有返回值。入参和返回值都是V。注意，即使这个方法也用E，也和上面的E不是同一个
     * @param v
     * @param <V>
     * @return
     */
    public <V> V methodWithReturn(V v) {
        return v;
    }
}

泛型类和泛型方法的使用场景

简单来说，一个类拥有多种同类型方法时使用泛型类，一个方法处理多种类型时使用泛型方法。

比如，在做数据访问层的时候，对一种类型的实体有一系列统一的访问方法，此时采用泛型类会比较合适，而对于
接口的统一结果封装则采用泛型方法比较合适，比如：

@Data
@NoArgsConstructor
public class Result<T> implements Serializable {

    private Integer code;
    private String message;
    private T data;

    private Result(Integer code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    private Result(Integer code, String message) {
        this.code = code;
        this.message = message;
        this.data = null;
    }

    /**
     * 带数据成功返回
     * 请注意，虽然泛型方法也用了T，但和Result<T>里的没关系
     * 这里之所以这么写，是因为实际开发时你们会见到很多这种“迷惑性”的写法，放出来作为“反例”，推荐最好使用其他符号，比如K
     *
     * @param data
     * @param <T>
     * @return
     */
    public static <T> Result<T> success(T data) {
        return new Result<>(ExceptionCodeEnum.SUCCESS.getCode(), ExceptionCodeEnum.SUCCESS.getDesc(), data);
    }
}

又比如封装工具类，也非常常用：

public class ConvertUtil {

    private ConvertUtil() {
    }

    /**
     * 将List转为Map
     *
     * @param list         原数据
     * @param keyExtractor Key的抽取规则
     * @param <K>          Key
     * @param <V>          Value
     * @return
     */
    public static <K, V> Map<K, V> listToMap(List<V> list, Function<V, K> keyExtractor) {
        if (list == null || list.isEmpty()) {
            return new HashMap<>();
        }
        Map<K, V> map = new HashMap<>(list.size());
        for (V element : list) {
            K key = keyExtractor.apply(element);
            if (key == null) {
                continue;
            }
            map.put(key, element);
        }
        return map;
    }
}

静态方法无法使用泛型类的类型参数，换言之，静态方法如果想要使用泛型，只能是静态泛型方法，此时类型参数是自己声明的。

泛型与类的实例相关联，静态方法与类的实例无关。

Redis分布式锁

public interface RedisService {

    // 省略其他方法...

    /**
     * 从队列取出消息
     *
     * @param queue    自定义队列名称
     * @param timeout  最长阻塞等待时间
     * @param timeUnit 时间单位
     * @return
     */
    Object popQueue(String queue, long timeout, TimeUnit timeUnit);
    
    // 省略其他方法...
}

但如果使用泛型方法：

public interface RedisService {

    // 省略其他方法...

    /**
     * 从队列取出消息
     *
     * @param queue    自定义队列名称
     * @param timeout  最长阻塞等待时间
     * @param timeUnit 时间单位
     * @return
     */
     <T> T popQueue(String queue, long timeout, TimeUnit timeUnit);
    
    // 省略其他方法...
}

就不用强制转换了。

但这并不保险，只是骗过了编译器而已。你会发现你用任意类型接收都是不会编译报错的：

泛型数组

Java并不支持泛型数组，所以对于ArrayList，底层仍旧采用Object[]。但在日常开发中又确实可能遇到需要new T[]的场景。

public class Test {

    public static void main(String[] args) {
        Integer[] array = new Integer[]{2, 4, 5, 9, 7, 1, 1, 6};
        Integer[] copyArray = copy(array);
    }

    private static <E> E[] copy(E[] array) {
        // 创建同类型数组
        E[] arrayTemp = ...
        
        for (int i = 0; i < array.length; i++) {
            arrayTemp[i] = array[i];
        }
        return arrayTemp;
    }
    
}

和new T()一样，new T[]也是不合法的。

要想new T()，要么方法传入Class<T>，要么通过GenericType获取，最终要通过反射创建T对象（总之要明确Class对象）。那么对于T[]，如何获取数组的元素类型呢？

JDK另外提供了所谓的ComponentType指代数组的元素类型：

泛型机制对普通对象、容器对象都很好，唯独对数组苛刻了些，以至于我们回想泛型，基本都想不起数组和泛型有啥关系。这不，为了弥补对数组的亏欠，Java特别给数组搞了ComponentType，其他两个可没有哦。

好了，既然知道了数组元素的类型，那就可以创建对应类型的数组咯：

public class Test {

    public static void main(String[] args) {
        Integer[] array = new Integer[]{2, 4, 5, 9, 7, 1, 1, 6};
        Integer[] copyArray = copy(array);
    }

    private static <E> E[] copy(E[] array) {
        Class<?> componentType = array.getClass().getComponentType();
        
        // 创建同类型数组
        E[] arrayTemp = (E[]) Array.newInstance(componentType, array.length);
        
        for (int i = 0; i < array.length; i++) {
            arrayTemp[i] = array[i];
        }

        return arrayTemp;
    }
    
}

newInstance方法：

其中的newArray是native修饰的

当然，实际开发中要想拷贝数组，有很多其他简单的方式，对于带有泛型参数 [[003-数组、排序、查找#Arrays.copyOf(int[] original,int newLength)|Arrays.copyOfRange]] 的方法来说，JDK的实现如下：

可以看到也是通过Array.newInstance()创建数组对象的。

泛型的应用

Lists是Google提供的工具类，返回一个List集合：

public final class Lists {  
    private Lists() {  
    }  
  
    @GwtCompatible(  
        serializable = true  
    )  
    public static <E> ArrayList<E> newArrayList() {  
        return new ArrayList();  
    }
}

此处定义了返回值的泛型，我们可以使用任意泛型进行接收

实际上，我们自定义一个方法：

ArrayList newArrayList(){  
    return new ArrayList();  
}

即便没有声明泛型，我们也可以使用任意泛型进行接收:

List<String> arrayList = newArrayList();

也就是：

public void doSome() {  
	//并不会报错
    List<String> arrayList = newArrayList();  
}  
  
public ArrayList newArrayList() {  
    return new ArrayList();  
}

Lambda表达式

Lambda表达式是JDK1.8的一个新特性，可以取代大部分的匿名内部类操作，以便写出更优雅的代码，尤其是在集合的操作中，可以极大优化代码结构。

在之前的学习中，如果想对List集合进行降序排列，就需要使用匿名内部类来实现，代码比较繁琐：

// 方式一：使用匿名内部类来实现
List<Integer> list = Arrays.asList(3, 6, 1, 7, 2, 5, 4);
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});
System.out.println("排序后：" + list);

针对以上对List集合的的“降序”排序操作，除了使用匿名内部类来实现外，还可以使用Lambda表达式来实现，使用Lambda表达式的代码非常优雅，并且还非常的简洁，代码如下：

// 方式二：使用Lambda表达式来实现
List<Integer> list = Arrays.asList(3, 6, 1, 7, 2, 5, 4);
Collections.sort(list, (o1, o2) -> o2 - o1);
System.out.println("排序后：" + list);

引例

// Math.abs()是JavaScript的内置函数
let result = Math.abs(-10)
console.log('result=' + result)

// JavaScript允许将Function赋值给变量。注意，不能带()，否则就是方法调用
let func = Math.abs

// 更神奇的是，func变量拼上()就可以当方法调用了
console.log('result=' + func(-20))

// 其实，在JavaScript中不仅允许方法赋值，还允许直接传递Function
function sum(x, y, func) {
	return func(x) + func(y)
}

result = sum(-10, -20, Math.abs)
console.log('result=' + result)

结果：

result=10
result=20
result=30
sandbox> exited with status 0

这种写法对于Java程序员来说第一感觉是“神奇”，紧接着能感受到JS的“轻巧”。

其实不仅是JS，Python也是如此：

# encoding: utf-8

# abs是Python的内置函数
result = abs(-1)
print(result)

# 定义add()方法，f显然是一个函数
def add(x, y, f):
    return f(x) + f(y)

print(add(-1, -2, abs))

运行结果：

1
3
sandbox> exited with status 0

Python把上面的表达式称为高阶函数：

函数的参数可以是一个/多个函数
函数的返回值也可以是一个函数

在JS、Python等脚本语言的世界里，这种现象似乎很普遍，因为Function是那个世界的一等公民，而对于Java来说对象才是一等公民。比如，有时为了在A对象的方法中调用B对象的某个方法，我们不得不new一个B对象并把它作为参数传入：

class A {
    public void methodA(B b) {
        System.out.println("methodA is called");
        b.methodB();
    }
}

class B {
    public void methodB() {
        System.out.println("methodB is called");
    }
}

在设计模式中，上面这种写法美其名曰：策略模式。

当然，广义上策略模式关注的是可替换的多种实现，狭义上可以理解为传递不同的方法。

幸运的是Oracle紧跟潮流，终于在2014年发布Java8并宣布支持Lambda表达式，弥补了Java函数式编程的遗憾。

出行案例

MyThread（模仿JDK的Thread，最大的区别是最终调用的还是主线程而不是异步线程）

public class MyThread {

    public void run() {
        System.out.println("去12306买了一张票");
        System.out.println("坐火车...");
    }

    public void start() {
        run(); 
    }
}

public class Demo {
    public static void main(String[] args) {
        // new一个MyThread对象，调用start()
        new MyThread().start();
    }
}

上面的代码有个问题：要运行的代码在MyThread的run里面写死了，我只能坐火车，不能坐飞机。分析：

我们知道，Java是面向对象的，一个事物一般可以最终抽象成属性+方法。

属性代表你有什么，方法代表你能干什么。

在这个案例中，“坐火车”、“坐飞机”都是一个动作。按上面分析，应该是一个方法。我们要动态地传入一个动作，也就是要动态地传入一个方法。但是我们知道，在Java中只能传递数据（参数），不能传递方法。JS之所以可以传递function，是因为function本身是JS的一种数据类型。

抽取一下上面的观点：

Java只能传递规定的数据类型的数据，比如int型的age， String型的name，引用类型的person。

对象包含属性和方法，而Java又可以传递person这样的引用类型。那么就完全可以传递一个对象（包含需要的方法），在内部调用对象的方法，这和直接传递方法是异曲同工的。

所以，我打算把“坐火车”、“坐飞机”这些交通策略单独抽取成一个个类，在new MyThread()的时候通过构造函数传递这些类的实例进去。

但同时可以预见，“坐火车”、“坐飞机”等等对象会非常多，MyThread的有参构造的形参类型需要形成多态。于是我写了一个MyRunnable接口，让每个策略类都去实现它（接口多态）。

public interface MyRunnable {
    void run();
}

public class ByTrain implements MyRunnable {
    @Override
    public void run() {
        System.out.println("去12306买了一张票");
        System.out.println("坐火车...");
    }
}

public class ByAir implements MyRunnable {
    @Override
    public void run() {
        System.out.println("在某App上订了飞机票");
        System.out.println("坐飞机...");
    }
}

public class ByAir implements MyRunnable {
    @Override
    public void run() {
        System.out.println("在某App上订了飞机票");
        System.out.println("坐飞机...");
    }
}

改写MyThread，接收不同的出行策略并调用方法:

public class MyThread {

    // 成员变量
    private MyRunnable target;

    public MyThread() {}
    
    // 构造方法，接收外部传递的出行策略
    public MyThread(MyRunnable target) {
        this.target = target;
    }

    // MyThread自己的run()，现在基本不用了
    public void run() {
        System.out.println("去12306买了一张票");
        System.out.println("坐火车...");
    }

    // 如果外部传递了出行策略，就会调用该策略里的run()
    public void start() {
        if (target != null) {
            target.run();
        } else {
            this.run();
        }
    }
}

Demo：

public class Demo {
    public static void main(String[] args) {
        ByTrain byTrain = new ByTrain();
        new MyThread(byTrain).start();

        ByAir byAir = new ByAir();
        new MyThread(byAir).start();
    }
}

尽管使用了策略模式，上面的代码还是有问题。如果后面还有“坐电瓶车”、“骑自行车”等出行方式，那么出行策略类就太多了，会发生所谓的“类爆炸”。我们可以使用匿名类的方式继续改进Demo：

public class Demo {
    public static void main(String[] args) {
        new MyThread(new MyRunnable() {
            @Override
            public void run() {
                System.out.println("不用买票");
                System.out.println("骑电瓶车...");
            }
        }).start();
    }
}

到此为止这大概是JDK8之前我们能想到的最好的解决办法，不仅运用了策略模式，还使用匿名类的方式成功阻止了类的暴增。

但是，程序永远存在可优化的地方。于是，JDK8又帮我们向前迈进了一大步:

public class Demo {
    public static void main(String[] args) {
        new MyThread(() -> {
            System.out.println("不用买票");
            System.out.println("骑电瓶车...");
        }).start();
    }
}

非常简洁。

Java从诞生那天起，就是纯正的面向对象语言。而从1995年诞生至今，已经过去28年。期间程序届又诞生了很多优秀的语言。

长江后浪推前浪，一般来说后续的新语言在创建之初一定会吸取之前语言的教训，尽量规避之前的设计缺陷。所以，单从语言层面上讲，老的语言往往是没有优势的，甚至存在代码冗余，不够优雅等弊病。

Lambda表达式可以看做函数式编程的子集，但函数式编程绝对不是Java首创的，它只是看到别的语言用的挺好，自己也引入了而已。

Lambda表达式的本质

Lambda表达式，其实是一段可传递的代码。

更精确的描述是：Lambda表达式，其实是一段可传递的代码。它的本质是以类的身份，干方法的活。

public class Demo {
    public static void main(String[] args) {
        new MyThread(() -> System.out.println("哈哈哈")).start();
    }
}

分析上面的代码，会发现new MyThread()这个构造方法原本需要传递一个MyRunnable接口的子类对象（匿名类对象）。但我们反手就扔了一个Lambda表达式进去，它还真吃下去了。说明什么？

说明Lambda表达式在身份上与匿名类对象等价。

但是Lambda表达式这么一串代码扔进去后，实际干活的也就->后的System.out.println("哈哈哈")这段代码（可以看做一个方法，因为方法是对代码块的封装）。这又说明了什么？

说明Lambda表达式在作用上与方法等价。

再次回味上面的那句话：Lambda表达式，其实是一段可传递的代码。Lambda本质是以类的身份，干方法的活。

如果我们把方法看做行为，那么Lambda表达式其实就是把行为参数化（方法作为参数传递）。

Lambda表达式格式解析

public class Demo {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abcd";

        int i = compareString(str1, str2, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        });
    }

    public static int compareString(String str1, String str2, Comparator<String> comparator) {
        return comparator.compare(str1, str2);
    }
}

以上的代码可以使用Lambda表达式优化：

由上文推导出Lambda表达式和匿名类对象等价，我们可以把Lambda表达式赋值给Comparator接口

可以看到，这段代码还有优化的空间；跳过赋值这一步，直接把整个Lambda传给compareString()方法：

还可以进行优化：

最终版本：

方法引用可以单纯地理解为可复用的Lambda（把其他类已经定义的方法作为Lambda），实际开发时依靠IDEA提示改进即可，并不需要我们记忆。

类名、方法名、形参类型、返回值类型、return关键字及方法体的{}都被省略了。

从语法格式来讲，Lambda表达式其实就是对一个方法掐头去尾，只保留形参列表和方法体。可以粗略认为：

Lambda表达式 = 形参列表 + 方法体

对于匿名内部类而言，类名、方法名真的没什么用。只有当一个方法需要被使用多次时，我们才需要为它命名，以便其他程序通过方法名重复调用。而匿名内部类的性质就是仅调用一次，所以名字对它来说是可有可无的。至于返回值与形参类型，Lambda都可以通过上下文推断，所以也可以省略：

// 基于上下文，很容易推算出返回值类型就是String。形参同理。
public someType get() {
    return "Hello World!";   
}

至于方法体的{}能不能省略，本质和if是否需要{}一样：

if(true) 
    System.out.println("可以省略{}"); 

if(true) {
    int i = 1;
    System.out.println("不可以省略{}"); 
}

至于是否需要return，看方法本身是否需要返回值。回顾上面的推演过程，能省略的都省略后就成了现在的Lambda表达式。

那实际使用Lambda表达式需要注意什么呢？

关注如何编写Lambda，需要实现什么样的逻辑
不要关注当前Lambda将会被如何调用，出现在代码的哪一块

比如：

public static void main(String[] args) {
	// 原始数据
    List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3));
	// filter()方法需要传入一个过滤逻辑
    List<Integer> result = list.stream().filter(value -> value > 2).collect(Collectors.toList());
	
    System.out.println(result);
}

如果你只是调用者，尽量不要去想filter()方法内部代码是怎么写的，只需考虑如何实现过滤规则：大于2，所以你只要写一个能判断value是否大于2的Lambda并传入即可（value->value>2 就是入参->方法体）。

函数式编程思想

Java从诞生之日起就一直倡导“一切皆对象”，在Java语言中面向对象（OOP）编程就是一切，但是随着Pathon和Scala等语言的崛起和新技术的挑战，Java也不得不做出调整以便支持更加广泛的技术要求，即Java语言不但支持OOP还支持OOF（面向函数编程）。
JDK1.8引入Lambda表达式之后，Java语言也开始支持函数式编程，但是Lambda表达式不是Java语言最早使用的，目前C++、C#、Python、Scala等语言都支持Lambda表示。

面向对象的思想
- 做一件事情，找一个能解决这个事情的对象，然后调用对象的方法，最终完成事情。
函数式编程思想
- 只要能获得结果，谁去做的，怎么做的都不重要，重视的是结果，不重视实现过程。

在函数式编程语言中，函数被当成一等公民对待。在将函数当成一等公民的编程语言中，Lambda表达式的类型是函数，但是Lambda表达式却是一个对象，而不是函数，它们必须依附于一类特别的对象类型，也就是所谓的函数式接口。

简单点说，JDK1.8中的Lambda表达式就是一个函数式接口的实例，这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以使用Lambda表示来表示。

如何去理解函数式接口

能够使用Lambda表达式的一个重要依据是必须有相应的函数式接口，所谓的函数式接口，指的就是“一个接口中有且只能有一个抽象方法”。也就是说，如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口。

如果我们在接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，也就是该接口中有且只能定义一个抽象方法，如果该接口中定义了多个或0个抽象方法，则程序编译时就会报错。

【示例】定义一个函数式接口

@FunctionalInterface
public interface Flyable {
    // 在函数式接口中，我们有且只能定义一个抽象方法
    void showFly();
    // 但是，可以定义任意多个默认方法或静态方法
    default void show() {
        System.out.println("JDK1.8之后，接口还可以定义默认方法和静态方法");
    }
}

另外，从某种意义上来说，只要你保证你的接口中有且只有一个抽象方法，则接口中没有使用 @FunctionalInterface 注解来标注，那么该接口也依旧属于函数式接口。

在以下代码中，Flyable接口中没有使用@FunctionalInterface 注解，但是Flyable接口中只存在一个抽象方法，因此Flyable接口依旧属于函数式接口，那么使用Lambda表达式就可以表示Flyable 接口的实例，代码如下：

/**
 * 没有使用@FunctionalInterface标注的接口
 */
public interface Flyable {
    void showFly();
}
/**
 * 测试类
 */
public class Test01 {
    public static void main(String[] args) {
        // 使用lambda表示来表示Flyable接口的实例
        Flyable flyable = () -> {
            System.out.println("小鸟自由自在的飞翔");
        };
        // 调用Flyable接口的实例的showFly()方法
        flyable.showFly();
    }
}

如果接口中有两个抽象方法：

Lambda表达式不能用了：

只能用匿名类对象，把两个方法都实现：

因为Lambda的本质是传递一个方法体，而MyRunnable此时有两个方法需要实现，那么你这个Lambda表达式到底是给哪个方法的呢？另一个又该怎么办呢？此时只能用匿名类对象，把两个方法都实现。

当然，我们还可以从另一个角度理解：Java8的Lambda都是基于上下文推导的，当一个接口只有一个方法时，推导结果是唯一确定的，但是方法不唯一时，无法推导得到唯一结果。

Lambda和匿名内部类

所需类型不同
- 匿名内部类：可以是接口，抽象类，具体类。
- Lambda表达式：只能是接口。
使用限制不同
- 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类。
- 如果接口中有多个抽象方法，则就只能使用匿名内部类，而不能使用Lambda表达式。
实现原理不同
- 匿名内部类：编译之后，会生成一个单独的.class字节码文件。
- Lambda表达式：编译之后，没有生成一个单独的.class字节码文件。

上面的案例一直在对比匿名内部类和Lambda，大家可能认为Lambda等同于匿名内部类，认为Lambda是匿名内部类的语法糖。但其实并不是。

public class Lambda {  
    public static void main(String[] args) {  
        // 在匿名内部类的外面定义一个String变量  
        final String str = "hello";  
        // 构造一个匿名内部类对象  
        Runnable r = new Runnable() {  
            @Override  
            public void run() {  
                System.out.println(str);  
                System.out.println("this--->" + this);  
            }  
            /**  
             * hello             
             * this--->lambdatest.Lambda$1@482ad665 
             * */        
             };  
        new Thread(r).start();  
    }  
}

注意，带$表示匿名内部类，比如LambdaTest$1表示LambdaTest中的匿名内部类，编译后会产生两个文件。

但如果把Runnbale换成Lambda表达式实现：

public void test(){  //不能在静态方法中使用this
    
    final String str = "hello";  
	//lambda表达式
    Runnable r = () -> {  
        System.out.println(str);  
        System.out.println("this--->" + this);  
    };  
    /**  
     * hello     
     * this--->lambdatest.Lambda@5e7e0ff3
     * */    
     new Thread(r).start();  
}

发现Lambda表达式方法体内部的this指向了LambdaTest，而且编译后也只有一个class文件。

Lambda方法体外部并没有匿名内部类，当然只能指向LambdaTest。更准确地说，this是指向方法的调用者，是隐式传递的。从这个角度看，Lambda和匿名内部类本质上还是不同的。

以后编码时，再遇到这种编译错误就不会迷惑了：

改成Lambda表达式即可，因为Lambda表达式外层就是当前类的实例：

根据IDEA提示，做一下简化：

Lambda表达式的使用

Lambda表达式本质就是一个匿名函数，在函数的语法中包含返回值类型、方法名、形参列表和方法体等，而在Lambda表达式中我们只需要关心形参列表和方法体即可。

在Java语言中，Lambda表达式的语法为“(形参列表) -> {方法体}”，其中“->”为 lambda操作符或箭头操作符，“形参列表”为对应接口实现类中重写方法的形参列表，“方法体”为对应接口实现类中重写方法的方法体。

接下来，我们就以匿名内部类为例，从而将匿名内部类演化为Lambda表达式，代码如下：

List<Integer> list = Arrays.asList(3, 6, 1, 7, 2, 5, 4);
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});
System.out.println("排序后：" + list);

在以上的代码中，第5行是完成功能的核心代码，因此将此处的匿名内部类转换为Lambda表达式，我们只需要保留形式参数列表和方法体即可，对应代码：

List<Integer> list = Arrays.asList(3, 6, 1, 7, 2, 5, 4);
Collections.sort(list, (Integer o1, Integer o2) -> {
    return o2 - o1;
});
System.out.println("排序后：" + list);

因此Lambda本质上就是去掉了一堆没有意义的代码，只留下核心的代码逻辑，从而让代码看起来更加的简洁且优雅。

Lambda表达式简化

形参类型可以省略，如果需要省略，则每个形参的类型都要省略。
如果形参列表中只存在一个形参，那么形参类型和小括号都可以省略。
如果方法体当中只有一行语句，那么方法体的大括号也可以省略。
如果方法体中只有一条return语句，那么大括号可以省略，且必须去掉return关键字。

闭包

在前文中的示例中：

我们可以看到，如果将str的final去掉并重新赋值，报错：lambda表达式中的变量应该是final的

这要从闭包现象开始解释，闭包由英文 closure 翻译而来。

闭包 = 环境 + 控制

闭包分为：

闭包现象：两个函数嵌套，里层函数使用到外层函数的变量，就出现了闭包现象。
闭包函数：内层函数就是闭包函数

def f():
	a = 5
	def g():
		print(a) # g函数就是闭包函数

	return g

《js高级程序设计》里面说：闭包是函数，是一个可以访问其他函数作用域中变量的函数。

f函数并不能访问g函数里面的变量，只有内部函数可以访问外部函数的变量。类似于内部类可以直接访问外部类，而外部类并不能直接访问内部类的变量。

上文的示例：

return之后：

return的不仅仅是g函数，还带有外面的一层环境信息

def f():
	a = 5
	def visit():
		print(a) # visit函数就是闭包函数

	def add():
		nolocal a
		a += 1
		
	return visit,add

g1 = f() # 拿到闭包
g1() # 5

如果调用多次：

def f():
	a = 5
	def visit():
		print(a) # visit函数就是闭包函数

	def add():
		nolocal a
		a += 1
		
	return visit,add

add, v = f()
add()  
v()   # 2
add()
v()   # 3
add()
v()   # 4

v函数和add函数的环境共享了，对变量a的操作只能通过这两个函数来完成，这就是一种小的封装

改写g函数：

def f():
	a = 5
	def g():
		nolocal a
		a += 1
		print(a) 

	return g

g1 = f()
g2 = f()

g1() # 2
g1() # 3
g1() # 4

g2() # 2
g2() # 3
g2() # 4

以上两个闭包中，a的值并不是同一个，类似于：

每次return都是将环境拷贝一份放出去了，这两个a是独立的a

如果外层环境中有多个变量，内层函数只使用了1个变量，闭包的环境也只有一个变量

如果是引用类型的变量，两个闭包指向的内存地址也是不同的，会对数组进行深拷贝。

Java中的闭包

但是在Java里我们看不到这样的结构，因为Java语法不允许直接的函数嵌套和跨域访问变量。

但是Java到处都是闭包，反而让我们感觉不到在使用闭包。因为Java的对象实际上就是一种闭包的结构。无论是闭包还是对象都是封装数据的一种手段。

class Add{
	private int x = 2;
	public int add(){
		int y = 3;
		return x + y;
	}
}

看上去x在add作用域之外，但是通过Add类实例化的过程，变量x和数值2之间已经绑定了，而且和方法add都打包在了一起。add函数其实是通过this关键字来访问对象的成员字段的。

Java中内部类就是一个经典的闭包结构：

public class Outer{
	private int x = 100;

	private class Inner{
		private y = 100;
		public int innerAdd(){
			return x + y;
		} 
	}
}

下图就是上文代码的结构。内部类通过包含一个指向外部类的引用，做到自由访问外部环境类的所有字段，变相把环境中的自由变量封装到函数中，形成一个闭包。

但Java匿名内部类做的比较尴尬。下面的例子中，getAnnoInner负责返回一个匿名内部类的引用。

interface AnnoInner{  
    int addXYZ();  
}  
public class Outer {  
    public AnnoInner getAnnoInner(final int x){  
        final int y = 100;  
        return new AnnoInner() {  
            int z = 100;  
            @Override  
            public int addXYZ() {  
                return x + y + z;  
            }  
        };  
    }  
}

匿名内部类不能显式地声明构造函数，也不能向构造函数中传参数。不但返回的只是个AnnoInner接口，而且还没有和它外围环境getAnnoInner方法的局部变量x和y构成任何类的结构。但它的addXYZ方法却直接使用了x和y两个自由变量计算结果。这就说明，外部方法getAnnoInner事实上已经对内部类AnnoInner构成了一个闭包。

但是这里x和y都必须用final修饰，不可以修改。如果用一个changeY方法试图修改外部getAnnoInner里的成员变量y，编译不通过：不能对final变量y重新赋值。

原因在于，Java编译器支持了闭包，但支持的不完整。说支持了闭包，是因为编译器编译的时候对方法进行了修改，将外部环境方法的x和y，拷贝了一份到匿名内部类当中，代码如下图所示：

public class Outer {  
    public AnnoInner getAnnoInner(final int x){  
        final int y = 100;  
        return new AnnoInner() {  
                    int copyX = x;  //拷贝副本
                    int copyY = y;  //拷贝副本
            int z = 100;  
            @Override  
            public int addXYZ() {  
                return x + y + z;  
            }  
        };  
    }  
}

Java编译器实现的是capture by value，并没有实现capture by reference。

capture by value：值捕获，在需要创建闭包的地方把捕获的值拷贝一份到对象里即可。Java的匿名内部类和lambda表达式都是这样实现的。
capture by reference：引用捕获，把捕获的局部变量hoist提升到对象里。C#的匿名函数（匿名委托/lambda表达式）就是这样实现的

而只有后者才能保持匿名内部类和外部环境变量保持同步。

但Java没有明确指出，既然内外不能同步，直接不允许修改外部环境的局部变量了。

几种不太常用的内部类形式，都有这个特性：方法的局部内部类等。

如果变量是不可变的，那么使用者无法感知值捕获和引用捕获的区别。

其他语言的捕获方式：

C++ 11 允许显式指定捕获列表以及捕获方式，这样最清晰。
JS只有引用捕获，要模拟值捕获的效果需要手动创建闭包和局部变量。
C#对不可变量做值捕获，对普通局部变量做引用捕获；由于无法感知对不可变量做值捕获或引用捕获的区别，统一把这个行为描述为引用捕获更方便一点。
Java虽然只实现了值捕获，但是又当又立不承认自己只做了值捕获，只允许捕获事实上不变量
python的lambda实现的是引用捕获，但在lambda内不能对捕获的变量赋值，只能在原本定义那些变量的作用域中对其赋值。

但是Java只不允许改变被lambda表达式捕获的变量，并没有限制这些变量指向的对象状态是否能改变，要从lambda表达式向外传值的常见workaround之一就是用长度为1的数组。JDK内部有些代码就使用的这种方法。

其他关于匿名内部类定义final的回答：

1)从程序设计语言的理论上:局部内部类(即:定义在方法中的内部类),由于本身就是在方法内部(可出现在形式参数定义处或者方法体处),因而访问方法中的局部变量(形式参数或局部变量)是天经地义的.是很自然的

2)为什么JAVA中要加上一条限制:只能访问final型的局部变量?

3)JAVA语言的编译程序的设计者当然全实现:局部内部类能访问方法中的所有的局部变量(因为:从理论上这是很自然的要求),但是:编译技术是无法实现的或代价极高.

4)困难在何处?到底难在哪儿?

局部变量的生命周期与局部内部类的对象的生命周期的不一致性!

5)设方法f被调用,从而在它的调用栈中生成了变量i,此时产生了一个局部内部类对象inner_object,它访问了该局部变量i .当方法f()运行结束后,局部变量i就已死亡了,不存在了.但局部内部类对象inner_object还可能一直存在(只能没有人再引用该对象时,它才会死亡),它不会随着方法f()运行结束死亡。这时，出现了一个"荒唐"结果:局部内部类对象inner_object要访问一个已不存在的局部变量i!

6)如何才能实现?当变量是final时,通过将final局部变量"复制"一份,复制品直接作为局部内部中的数据成员.这样:当局部内部类访问局部变量时,其实真正访问的是这个局部变量的"复制品"(即:这个复制品就代表了那个局部变量).因此:当运行栈中的真正的局部变量死亡时,局部内部类对象仍可以访问局部变量(其实访问的是"复制品"),给人的感觉:好像是局部变量的"生命期"延长了.

那么:核心的问题是:怎么才能使得:访问"复制品"与访问真正的原始的局部变量,其语义效果是一样的呢?

当变量是final时,若是基本数据类型,由于其值不变,因而:其复制品与原始的量是一样.语义效果相同.(若:不是final,就无法保证:复制品与原始变量保持一致了,因为:在方法中改的是原始变量,而局部内部类中改的是复制品)

当变量是final时,若是引用类型,由于其引用值不变(即:永远指向同一个对象),因而:其复制品与原始的引用变量一样,永远指向同一个对象(由于是final,从而保证:只能指向这个对象,再不能指向其它对象),达到:局部内部类中访问的复制品与方法代码中访问的原始对象,永远都是同一个即:语义效果是一样的.否则:当方法中改原始变量,而局部内部类中改复制品时,就无法保证:复制品与原始变量保持一致了(因此:它们原本就应该是同一个变量.)

字节码层面测试

public interface MyInterface {
    void doSomething();
}

public class TryUsingAnonymousClass {
    public void useMyInterface() {
        final Integer number = 123;
        System.out.println(number);

        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println(number);
            }
        };
        myInterface.doSomething();

        System.out.println(number);
    }
}

反编译匿名内部类：

class TryUsingAnonymousClass$1
        implements MyInterface {
    private final TryUsingAnonymousClass this$0;
    private final Integer paramInteger;

    TryUsingAnonymousClass$1(TryUsingAnonymousClass this$0, Integer paramInteger) {
        this.this$0 = this$0;
        this.paramInteger = paramInteger;
    }

    public void doSomething() {
        System.out.println(this.paramInteger);
    }
}

可以看到名为number的局部变量是作为构造方法的参数传入匿名内部类的（以上代码经过了手动修改，真实的反编译结果中有一些不可读的命名）。

如果Java允许匿名内部类访问非final的局部变量的话，那我们就可以在TryUsingAnonymousClass$1中修改paramInteger，但是这不会对number的值有影响，因为它们是不同的reference。这就会造成数据不同步的问题。

而Scala中的代码会编译为这样：

public final class TryUsingAnonymousClassInScala$$anonfun$1 extends AbstractFunction0.mcV.sp
        implements Serializable {
    public static final long serialVersionUID = 0L;
    private final IntRef number$2;

    public final void apply() {
        apply$mcV$sp();
    }

    public void apply$mcV$sp() {
        this.number$2.elem = 456;
        Predef..MODULE$.println(BoxesRunTime.boxToInteger(this.number$2.elem));
    }

    public TryUsingAnonymousClassInScala$$anonfun$1(TryUsingAnonymousClassInScala $outer, IntRef number$2) {
        this.number$2 = number$2;
    }
}

可以看到number也是通过构造方法的参数传入的，但是与Java的不同是这里的number不是直接传入的，是被IntRef包装了一层然后才传入的。对number的值修改也是通过包装类进行的：this.number$2.elem = 456;

这样就保证了lambda表达式内外访问到的是同一个对象。

四个基本的函数式接口

以上的函数式接口都在java.util.function包中，通常函数接口出现的地方都可以使用Lambda表达式，所以不必记忆函数接口的名字

接口多态与方法多态

多态，原本指的是接口下有多个子类实例可以指向接口引用，但由于函数式接口恰好仅有一个方法，此时接口多态等同于“方法多态”，即一个抽象方法拥有多个不同的具体实现。

接口多态

多态的精髓在于晚绑定：

PocketMon pocketMon = new Pikaqiu();
pocketMon.releaseSkill();

只看pocketMon.releaseSkill()你能猜出来技能是电击还是喷火吗？换一种形式呢？

Properties pro = new Properties();
FileInputStream in = new FileInputStream("pocketmon.properties");
pro.load(in);
PocketMon pocketMon = Class.forName(pro.getProperty("nextPocketMon")).newInstance();
pocketMon.releaseSkill();

完全看不出来了。

即使你打开pocketmon.properties看了是皮卡丘，运行时虚拟机看到的可能是我修改后的喷火龙。

这种现象其实很奇妙：明明代码都写死了，但虚拟机却无法提前确定具体会是哪只神奇宝贝在调用releaseSkill()，除非实际运行到这行代码。而这，正是得益于多态。

多态的原理，本质是还是JVM层面通过运行时查找方法表实现的。可以简单理解为，JVM在运行时需要去循环遍历这个方法对应的多态实现，选择与当前运行时对象匹配的方法进行调用。所以，从理论上来说，晚绑定的多态在性能上是不如早绑定的（直接写死，不用多态）。而多态是设计模式的灵魂，所以对于一些非常、非常、非常要求性能的场景来说，过于繁重的设计反而会降低性能。说白了，这世上就不存在多、快、好、省。

多态是“晚绑定”思想的体现：对于Java而言，方法的调用并不是编译时绑定，而是运行时动态绑定的，取决于引用具体指向的实例。

方法多态

这个概念在函数式接口的前提下是站得住脚的，而且有利于跳出面向对象，贴近函数式编程。

需求：要求写一个cook()方法，传入鸡翅和可乐，做出可乐鸡翅。

很多人可能下意识地就把代码写死了：

public static CokaChickenWing cook(Chicken chicken, Coka coka){
    1.放油、放姜;
    2.放鸡翅;
    3.倒可乐;
    4.return CokaChickenWing;
}

但是，网上也有人说应该先倒可乐再放鸡翅，每个人的口味不同，做法也不同。有没有办法把这两步延迟确定呢？让调用者自己来安排到底是先倒可乐还是先放鸡翅。

可以这样：

public static CokaChickenWing cook(Chicken chicken, Coka coka, function twoStep){
    1.放油、放姜;
    2~3.twoStep();
    4.return CokaChickenWing;
}

想法很好：既然这两步不确定，那么就由调用者来决定吧，让调用者自己传进来。

我们知道Java是不能直接传递方法的，但利用策略模式可以解决这个问题。

定义一个接口：

interface TwoStep {
    void excute();
}

public static CokaChickenWing cook(Chicken chicken, Coka coka, TwoStep twoStep){
    1.放油、放姜;
    2~3.twoStep.excute();
    4.return CokaChickenWing;
}

这里twoStep.excute()是确定的吗？

没有。方法里的参数放在栈帧中的局部变量表里，必须是程序执行到该方法时，方法才入栈，分配相应内存与数据，所以是不能提前确定的。

所以twoStep.excute()充其量只是先替“某些操作占个坑”，后面再确定。

什么时候确定呢？

main(){
   
   TwoStep twoStep = new TwoStep(){
    	@Override
        public void excute(){
            2.先放鸡翅
            3.再倒可乐
        }
   }
   // 或者
   TwoStep twoStep = () -> {2.先放鸡翅;3.再倒可乐}
   // 调用cook时确定（运行时）
   cook(chicken, coka, twoStep);
}

public static CokaChickenWing cook(Chicken chicken, Coka coka, TwoStep twoStep){
    1.放油、放姜;
    2~3.twoStep.excute();
    4.return CokaChickenWing;
}

学习过Lambda表达式就可以换一种写法：

main(){
   // 调用cook时确定 方案1
   cook(chicken, coka, () -> 2.先放鸡翅，3.再倒可乐);
   // 调用cook时确定 方案2
   cook(chicken, coka, () -> 2.先倒可乐，3.再放鸡翅);
}

public static CokaChickenWing cook(Chicken chicken, Coka coka, TwoStep twoStep){
    1.放油、放姜;
    2~3.twoStep.excute();
    4.return CokaChickenWing;
}

这就是所谓的“方法多态”：通过函数式接口把形参的坑占住，后续传入不同的Lambda实现各自逻辑。

晚绑定和模板方法设计模式

在设计模式中策略模式和模板方法看起来有点像，但其实不一样。策略模式使用接口占坑，然后传入实际对象调用需要的方法，而模板方法模式是用抽象方法占坑，粒度其实小一些。

晚绑定最典型的应用就是模板方法模式：抽象类确定基本的算法骨架，把不确定的、变化的部分做成抽象方法剥离出去，由子类来实现。

还是以发送验证码为例：

/**
 * 验证码发送器
 *
 * @author qiyu
 * @date 2020-09-08 19:38
 */
public abstract class AbstractValidateCodeSender {

    /**
     * 生成并发送验证码
     */
    public void sendValidateCode() {
        // 1.生成验证码
        String code = generateValidateCode();

        // 2.把验证码存入Session
        // ....

        // 3.抽象方法占坑，用于发送验证码
        sendCode();
    }

    /**
     * 具体发送逻辑，留给子类实现：发送邮件、或发送短信都行
     */
    protected abstract void sendCode();

    /**
     * 生成验证码
     *
     * @return
     */
    public String generateValidateCode() {
        return "123456";
    }

}

对于上面的模板，我们可以有多种实现方式，以便把sendCode()这个坑填上：

/**
 * 短信验证码发送
 *
 * @author qiyu
 * @date 2020-09-08 19:44
 */
public class SmsValidateCodeSender extends AbstractValidateCodeSender {

    @Override
    protected void sendCode() {
        // 通过阿里云短信发送
    }
}

/**
 * QQ邮箱验证码发送
 *
 * @author qiyu
 * @date 2020-09-08 19:45
 */
public class EmailValidateCodeSender extends AbstractValidateCodeSender {

    @Override
    protected void sendCode() {
        // 通过QQ邮箱发送
    }
}

内部迭代与外部迭代

外部迭代

简单理解外部迭代就是由用户来决定”做什么“和”怎么做“的操作。比如下面代码中”做什么“（把大写转成小写）与”怎么做“（通过 Iterator 遍历）是由用户来决定的。

List<String> example = Arrays.asList(new String[]{"A", "B", "C"});
 // 遍历List，把大写转成小写
Iterator<String> iterator = example.iterator();
while (iterator.hasNext()) {
  System.out.println(iterator.next().toLowerCase());
}

内部迭代

如果我们使用 Stream来操作集合的话可以这样写。

List<String> example = Arrays.asList(new String[]{"A", "B", "C"});
example.stream().forEach(e -> System.out.println(e.toLowerCase()));

Stream操作的是集合的流。

内部迭代我们只需要提供”做什么“，把”怎么做“的任务交给了 JVM。

使用内部迭代可以带来的好处:

用户只需要关注问题，无需关注如何解决问题的细节。
使得 JVM可以利用短路、并行等对性能的提升变成可能

StreamAPI 设计分析

Lambda底层原理其实是自动生成一个私有静态方法，并实现函数式接口，然后在函数式接口实现类的方法中调用这个私有静态方法。会有一些反编译操作。

模拟filter()

/**
 * 新建Predicate接口
 *
 * @param <T>
 */
@FunctionalInterface
interface Predicate<T> {
    /**
     * 定义了一个test()方法，传入任意对象，返回true or false，具体判断逻辑由子类实现
     *
     * @param t
     * @return
     */
    boolean test(T t);
}


/**
 * Predicate接口的实现类，泛型规定只处理Person
 */
class PredicateImpl implements Predicate<Person> {

    /**
     * 判断逻辑是：传入的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;
}

测试：

public class MockStream {

    public static void main(String[] args) {

        Person bravo = new Person("bravo", 18);

        // 1.具体实现类，调用它的test()方法
        Predicate<Person> predicate1 = new PredicateImpl();
        // test()内部代码是：bravo.getAge() > 18
        myPrint(bravo, predicate1); // false

        // 2.匿名类，调用它的test()方法
        Predicate<Person> predicate2 = new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() < 18;
            }
        };
        myPrint(bravo, predicate2); // false

        // 3.Lambda表达式，调用它的test()方法。
        // 按照Lambda表达式的标准，只要你是个函数式接口，那么就可以接收Lambda表达式
        Predicate<Person> predicate3 = person -> person.getAge() == 18;
        myPrint(bravo, predicate3); // true
    }

    public static void myPrint(Person person, Predicate<Person> filter) {
        if (filter.test(person)) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

myPrint(Person person, Predicate<Person> filter)的精髓是，用Predicate函数式接口先行占坑。我们无需关注Predicate传入myPrint()后将被如何调用，只要关注如何实现Predicate，又由于Predicate只有一个test()方法，所以最终我们只需关注如何实现test()方法。

而实现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<T>{
    private List<T> list = new ArrayList<>();
    
	// 1.外部调用add()添加的元素都会被存在list
    public boolean add(T t) {
        return list.add(t);
    }

    /**
     * 过滤方法，接收过滤规则
     * @param predicate
     * @return
     */
    public List<T> filter(Predicate<T> predicate){
        List<T> 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），只关心它能干什么（方法）。这也是面向对象和函数式编程的思维差异

模拟map()

再模拟一个map()。因为实际编程中，个人认为filter()和map()是最常用的，希望大家能理解它们的“原理”。

/**
 * 定义一个Function接口
 * 从接口看Function<E, R>中，E(Enter)表示入参类型，R(Return)表示返回值类型
 * 
 * @param <E> 入参类型
 * @param <R> 返回值类型
 */
@FunctionalInterface
interface Function<E, R> {
    /**
     * 定义一个apply()方法，接收一个E返回一个R。也就是把E映射成R
     *
     * @param e
     * @return
     */
    R apply(E e); //方法调用时，R被确定。
}

/**
 * Function接口的实现类，规定传入Person类型返回Integer类型
 */
class FunctionImpl implements Function<Person, Integer> {

    /**
     * 传入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>中，Person是入参类型，Integer是返回值类型
        Function<Person, Integer> function1 = new FunctionImpl();
        myPrint(bravo, function1);

        // 2.匿名类
        Function<Person, Integer> function2 = new Function<Person, Integer>() {
            @Override
            public Integer apply(Person person) {
                return person.getAge();
            }
        };
        myPrint(bravo, function2);


        // 3.Lambda表达式 person（入参类型） ->  person.getAge()（返回值类型）
        Function<Person, Integer> function3 = person -> person.getAge();
        myPrint(bravo, function3);
    }

    public static void myPrint(Person person, Function<Person, Integer> mapper) {
        System.out.println(mapper.apply(person));
    }
}

目前为止应该还蛮好理解的。

之前我们在MyList中写了个filter()方法并用Predicate接口占了坑，它接收一个“过滤器”来过滤元素。而现在，map()方法用Function接口占坑，它需要接收一个“转换器”来帮元素“变身”：

class MyList<T> {
    private List<T> list = new ArrayList<>();

    public boolean add(T t) {
        return list.add(t);
    }


    /**
     * 把MyList中的List<T>转为List<R>
     * 不要关注Function<T, R>接口本身，而应该关注apply()
     * apply()接收T t，返回R t。具体实现需要我们从外面传入，这里只是占个坑
     *
     * @param mapper
     * @param <R>
     * @return
     */
    public <R> List<R> map(Function<T, R> mapper) {
        List<R> mappedList = new ArrayList<>();

        for (T t : list) {
            // mapper通过apply()方法把T t 变成 R t，然后加入到新的list中
            mappedList.add(mapper.apply(t));
        }

        return mappedList;
    }

}

无论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。总之，坑已经占好了，注意一下入参和出参满足条件即可。

方法引用

方法引用和匿名对象、lambda表达式等价

方法引用就是将已有的方法拿过来用，可以作为函数式接口中抽象方法的方法体。

如果一个Lambda表达式只是调用某个方法，就可以使用方法引用。

有如下要求：

引用处必须是函数式接口
被引用的方法必须是已经存在的
被引用的方法的形参和返回值需要和抽象方法保持一致
被引用的方法功能满足当前的需求

现有如下代码：

假设现在有写好的代码：

就可以替换为：

::就是方法引用符

方法引用的分类

flowchart LR 1.引用静态方法 2.引用成员方法 --> 1.引用其他类的成员方法 & 2.引用本类的成员方法 & 3.引用父类的成员方法 3.引用构造方法 4.其他调用方式 --> 1.使用类名引用成员方法 & 2.引用数组的构造方法

引用静态方法

类名::静态方法
Integer::parseInt

练习：集合中有字符串类型数字，要求将其转换为int类型

List<String> list = Arrays.asList("1", "2", "3", "4");  
list.stream().map(Integer::parseInt).forEach(System.out::println);

map的参数：函数式接口Function，消费T类型，生产R类型；方法的形参和返回值需要与抽象方法的形参和返回值保持一致。

方法的功能是把形参的字符串转换为整数

引用成员方法

对象::成员方法
 
    其他类：  其他类对象::方法名
    本类：    this::方法名
    父类：	 super::方法名

以上的都是在成员方法中引用其他成员方法，静态方法里没有super和this，只能创建对象

练习1：集合中有一些名字，按照要求过滤数据

有成员方法：

class StringTool{  
    public boolean startWithWordAndSizeEqualsThree(String s){  
        return s.startsWith("张") && s.length() == 3;  
    }  
}

在其他类引用这个其他类的成员方法

public static void main(String[] args) {  
    List<String> list = Arrays.asList("张三丰", "张无忌", "张无", "赵敏");  
    list.stream().map(new StringTool()::stringJudge).forEach(System.out::println);  
}

在子类引用这个成员方法：

class StringToolSub extends StringTool{  
    public void doSome(){  
        List<String> list = Arrays.asList("张三丰", "张无忌", "张无", "赵敏");  
        list.stream().map(super::stringJudge).forEach(System.out::println);  
    }  
}

因为public修饰的成员方法是可以被继承的，所以此处也可以使用this

在本类中引用这个成员方法

class StringTool{  
    public boolean stringJudge(String s){  
        return s.startsWith("张") && s.length() == 3;  
    }  
      
    public void doSome(){  
        List<String> list = Arrays.asList("张三丰", "张无忌", "张无", "赵敏");  
        list.stream().map(this::stringJudge).forEach(System.out::println);  
    }  
}

引用构造方法

引用构造方法是为了创建对象

类名::new
Student::new

List<String> list = Arrays.asList("张三丰-15", "张无忌-20", "张无-25", "赵敏-30");

需要在构造方法里对流中的每一个字符串进行处理

class Person{  
    private String name;  
    private Integer age;  
  
    public Person(String str) {  
        this(str.split("-")[0],Integer.parseInt(str.split("-")[1]));  
    }  
  
    public Person(String name, Integer age) {  
        this.name = name;  
        this.age = age;  
    }  
}

List<String> list = Arrays.asList("张三丰-15", "张无忌-20", "张无-25", "赵敏-30");  
list.stream().map(Person::new).forEach(System.out::println);

其他方式调用

类名引用成员方法

类名::成员方法
String::substring

练习：集合中的字符串，要求变成大写之后输出

list.stream().map(s -> s.toUpperCase()).forEach(System.out::println);

但是这样也可以这样调用：

List<String> list = Arrays.asList("abc", "def", "ghi", "jkm");  
list.stream().map(String::toUpperCase).forEach(System.out::println);

toUpperCase方法：

public String toUpperCase(String this) {  
    return toUpperCase(Locale.getDefault());  
}

在调用时，正常情况下：

String s = "abc";
s.toUpperCase();

虚拟机在调用成员方法时，会隐含的将s引用赋值给隐含参数this，所以此时stream流中的每一个元素都赋值给参数this了，这样就可以通过类名来引用成员方法。

这里有两个问题：

成员方法需要使用对象调用
参数列表没有保持一致

这里遵守的是另一套规则：

如果某个Lambda表达式只是调用一个实例方法，并且参数列表中第一个参数作为方法的主调，后面的所有参数都是作为实例方法的入参，就可以使用类名引用实例方法

抽象方法形参：

第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法
在Stream流中，第一个参数一般都表示流里面的每一个数据。
假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用Srting类中的方法
第二个参数到最后一个参数：与被引用方法的形参保持一致，如果没有第二个参数，表示被引用的方法是无参的成员方法

也就是说明，流中的参数可以调用自身的成员方法，但是成员方法的形参需要与流的其他形参保持一致

也就是拿着流中的每一个数据，调用String类的toUpperCase方法

引用数组构造方法

数据类型[]::new
int[]::new

List<Integer> list = Arrays.asList(1, 2, 3, 4);  
list.stream().toArray(Integer[]::new);

练习

集合中存储："张三,23"类的字符串，收集到Person类型的数组中

class Person{  
    private String name;  
    private Integer age;  
  
    public Person(String str) {  
        this(str.split(",")[0],Integer.parseInt(str.split(",")[1]));  
    }  
  
    public Person(String name, Integer age) {  
        this.name = name;  
        this.age = age;  
    }  
}

List<String> list = Arrays.asList("张三,23", "张三,23", "张三,23", "张三,23");  
Person[] persons = list.stream().map(Person::new).toArray(Person[]::new);  
System.out.println(Arrays.toString(persons));

创建集合添加Person对象，只获取姓名放在数组中

class Person{  
    private String name;  
    private Integer age;  
  
    public Person(String str) {  
        this(str.split(",")[0],Integer.parseInt(str.split(",")[1]));  
    }  
  
    public Person(String name, Integer age) {  
        this.name = name;  
        this.age = age;  
    }
}

List<Person> list = List.of(new Person("张三,23"),new Person("张三,23"));  
String[] names = list.stream().map(Person::getName).toArray(String[]::new);  
System.out.println(Arrays.toString(names));

创建集合添加Person对象，把name和age拼接为：张三-23的字符串，放入数组

List<Person> list = List.of(new Person("张三,23"),new Person("张三,23"));  
String[] persons = list.stream()
				  .map(person -> person.getName() + "-" + person.getAge()).toArray(String[]::new); 
System.out.println(Arrays.toString(persons));

也可以重写Person的toString方法，引用这个toString

Lambda表达式与方法引用

引例

public class MethodReferenceTest {

    private static final List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person(19));
        list.add(new Person(18));
        list.add(new Person(20));
    }

    public static void main(String[] args) {
        System.out.println(list);
        // sort()方法是List本身就有的，主要用来排序
        list.sort((p1, p2) -> p1.getAge() - p2.getAge());
        System.out.println(list);
    }


    @Data
    @AllArgsConstructor
    static class Person {
        private Integer age;
    }

}

结果


排序前：

[MethodReferenceTest.Person(age=19), MethodReferenceTest.Person(age=18), MethodReferenceTest.Person(age=20)]

排序后：

[MethodReferenceTest.Person(age=18), MethodReferenceTest.Person(age=19), MethodReferenceTest.Person(age=20)]

把上面的案例稍作改动：

public class MethodReferenceTest {

    private static final List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person(19));
        list.add(new Person(18));
        list.add(new Person(20));
    }

    public static void main(String[] args) {
        System.out.println(list);
        // 改动2：既然Person内部有个逻辑一样的方法，就用它来替换Lambda
        list.sort(Person::compare);
        System.out.println(list);
    }

    @Data
    @AllArgsConstructor
    static class Person {
        private Integer age;

        // 改动1：新增一个方法，逻辑和之前案例的Lambda表达式相同
        public static int compare(Person p1, Person p2) {
            return p1.getAge() - p2.getAge();
        }
    }
}

从Lambda到方法引用

/**
 * 从匿名对象 到Lambda 再到方法引用
 *
 * @author qiyu
 */
public class MethodReferenceTest {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abcd";

        // 方式1：匿名对象
        Comparator<String> comparator1 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        };
        compareString(str1, str2, comparator1);


        // 方式2：过渡为Lambda表达式
        Comparator<String> comparator2 = (String s1, String s2) -> {
            return s1.length() - s2.length();
        };
        compareString(str1, str2, comparator2);

        // 方式2的改进版：省去赋值操作，直接把整个Lambda表达式作为参数丢进去
        compareString(str1, str2, (String s1, String s2) -> {
            return s1.length() - s2.length();
        });

        // 方式2的最终版：把变量类型和return也去掉了，因为Java可以自动推断
        compareString(str1, str2, (s1, s2) -> s1.length() - s2.length());


        // 方式3：换种比较方式，本质和方式2是一样的，不信你去看看String#compareTo()
        Comparator<String> comparator3 = (s1, s2) -> s1.compareTo(s2);


        // 方式4：IDEA提示有改进的写法，最终变成了方法引用
        compareString(str1, str2, String::compareTo);

        // 完美。

    }

    /**
     * 传递Comparator，对str1和str2进行比较
     *
     * @param str1
     * @param str2
     * @param comparator
     */
    public static void compareString(String str1, String str2, Comparator<String> comparator) {
        System.out.println(comparator.compare(str1, str2));
    }
}

我们在学习Lambda时，把它和匿名类作比较。因为匿名类和Lambda处理的逻辑是一样的，所以就用Lambda简化了匿名类：

同样的，如果项目中已经定义了相同逻辑的方法，我们为什么还要再写一遍呢？即使Lambda表达式再怎么简洁，终究还是要手写好几行代码。

所以，JDK在Lambda表达式的基础上又提出了方法引用的概念，允许我们复用当前项目（或JDK源码）中已经存在的且逻辑相同的方法。

比如上面那个例子中的：

// 方式3：换种比较方式，本质和方式2是一样的
Comparator<String> comparator3 = (s1, s2) -> s1.compareTo(s2);

// 方式4：IDEA提示有改进的写法，最终变成了方法引用
compareString(str1, str2, String::compareTo);

String::compareTo看起来形式有点诡异，但这只是一种语法而已，习惯就好了，关键是明白它代表什么意思。Java8引入::符号，用来表示方法引用。所谓的方法引用，就是把方法搬过来使用。那么，String::compareTo把哪个类的什么方法搬过来了呢？

一般来说，String类定义的compareTo方法的正常使用方式是这样的：

public class MethodReferenceTest {
    public static void main(String[] args) {
        String str = "hello";
        String anotherStr = "world";
        int difference = str.compareTo(anotherStr);
    }
}

作为更高阶的Lambda表达式，方法引用也能作为参数传递，于是就有了：

public class MethodReferenceTest {
    public static void main(String[] args) {
        String str = "hello";
        String anotherStr = "world";

        // 匿名内部类
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String str, String anotherStr) {
                return str.compareTo(anotherStr);
            }
        };

        // 方法引用。上面的str.compareTo(anotherStr)不就是String::compareTo吗！！
        Comparator<String> newComparator = String::compareTo;

        compareString(str, anotherStr, newComparator);
    }

    /**
     * 传递Comparator，对str1和str2进行比较
     *
     * @param str1
     * @param str2
     * @param comparator
     */
    public static void compareString(String str1, String str2, Comparator<String> comparator) {
        System.out.println(comparator.compare(str1, str2));
    }
}

总之，Java8的意思就是：

兄弟，如果已经存在某个方法能完成你的需求，那么你连Lambda表达式都别写了，直接引用这个方法吧。

但我个人更推荐Lambda表达式，原因有两个：

对初学者而言，Lambda表达式语义更清晰、更好理解
Lambda表达式细粒度更小，能完成更精细的需求

第一点，你懂的。

第二点，请容许我来证明一下。

Lambda表达式VS方法引用

/**
 * MyPredict是模拟Predict
 * MyInteger是模拟Integer
 * <p>
 * 本次测试的目的旨在说明：Lambda毕竟是手写的，自由度和细粒度要高于方法引用。
 *
 * @author sunting
 */
public class MethodAndLambdaTest {
    public static void main(String[] args) {
        // 1.匿名对象
        MyPredict myPredict1 = new MyPredict() {
            @Override
            public boolean test(int a, int b) {
                return a - b > 0;
            }
        };
        boolean result1 = myPredict1.test(1, 2); // false

        // 2.从匿名对象过渡到Lambda表达式
        MyPredict myPredict2 = (a, b) -> a - b > 0;
        myPredict2.test(1, 2); // false

        // 3.MyInteger#compare()的方法体和上面的Lambda表达式逻辑相同，可以直接引用
        MyPredict myPredict3 = MyInteger::compare;
        myPredict3.test(1, 2); // false

        // 4.Lambda说，你想模仿我？想得美！老子要DIY一下比较规则（a减b 变成了 b减a）
        MyPredict myPredict4 = (a, b) -> b - a > 0;
        myPredict4.test(1, 2); // true

        // 5.看到这，方法引用不服气，也想DIY一把
        MyPredict myPredict5 = MyInteger::compare;
        // ???，没法DIY，MyInteger::compare是把整个方法搬过来，不能修改内部的逻辑
    }
}

interface MyPredict {
    boolean test(int a, int b);
}

class MyInteger {
    public static boolean compare(int a, int b) {
        return a - b > 0;
    }
}

方法引用，其实就是把现成的某个方法拿来替代逻辑相似的Lambda表达式。

但Lambda表达式由(a, b) -> a - b > 0 变为 (a, b) -> b - a > 0 ，说明Lambda逻辑已经变了，此时原先的方法引用就不匹配了，不能再用了。此时我们最自然的想法应该是从现成的项目中找到逻辑和(a, b) -> b - a > 0相同的另一个方法，然后把那个方法引用过来，而不是想着改变原来的MyInteger::Compare，那不是你的方法，你也只是借用而已！！

所以，我们给MyInteger加一个方法吧：

class MyInteger {
    public static boolean compare(int a, int b) {
        return a - b > 0;
    }

    public static boolean anotherCompare(int a, int b) {
        return b - a > 0;
    }
}

这样，方法引用的逻辑又和Lambda匹配了：

public class MethodAndLambdaTest {
    public static void main(String[] args) {

        MyPredict myPredict2 = (a, b) -> a - b > 0;
        myPredict2.test(1, 2); // false

        MyPredict myPredict3 = MyInteger::compare;
        myPredict3.test(1, 2); // false

        MyPredict myPredict4 = (a, b) -> b - a > 0;
        myPredict4.test(1, 2); // true
		
        // MyInteger::anotherCompare的逻辑和上面的Lambda才是匹配的
        MyPredict myPredict5 = MyInteger::anotherCompare;
        myPredict5.test(1, 2); // true
    }

}

interface MyPredict {
    boolean test(int a, int b);
}

class MyInteger {
    public static boolean compare(int a, int b) {
        return a - b > 0;
    }

    public static boolean anotherCompare(int a, int b) {
        return b - a > 0;
    }
}

再看一个Stream API的例子：

filter此时需要的逻辑是：年龄大于等于30岁的teacher。

你能从现有项目中找到逻辑为“年龄大于等于30岁的teacher”的方法吗？

答案是没有。

你最多只能调用Teacher::getAge()，但是这个方法引用的逻辑是“获取老师的年龄”，而不是“是否大于等于30岁”，两者逻辑不同，无法替换。

那能不能使用 Teacher::getAge()>=30 呢？

答案是不能。

首先，filter()的参数要么是Lambda表达式，要么是方法引用，不能是方法引用+语句，不伦不类。

其次，也是最重要的，你可以认为Teacher::getAge表示

public Integer getAge(){
    return this.age;
}

中的return this.age;，它是一个语句。我们可以对表达式叠加判断，比如 a-b ，我们可以继续叠加变成 a-b+c。但是 int d = a-b+c; 已经没办法再叠加了，因为 int d = a-b+c; >= 30 是不可接受的！

处理办法也简单，就是找一个相同逻辑的方法并引用它。假设存在以下方法：

public boolean isBiggerThan30(){
    return this.age >= 30;
}

那就可以写成：

list.stream().filter(Teacher::isBiggerThan30);

后话

关于方法引用其实还可以展开说，比如可以分为：

静态方法引用（Integer::compare）
实例方法引用（this::getName、user::getName）
构造器方法引用（User::new）

总体来说，方法引用（包括构造器引用）的前提是，函数式接口的方法对应的参数列表和返回值 与引用类定义的方法的参数列表和返回值 一致。这样说可能比较绕，这里举一个demo：

public class StreamConstructorTest {

    public static void main(String[] args) {

        // 下面4个语句都是Person::new，却能赋值给不同的函数式接口
        // 原因是：每个函数式接口都能从Person类中找到对应的方法（参数列表一致），从而完成方法引用
        PersonCreatorNoConstruct person1 = Person::new;

        // 大家可以尝试把Person中Age构造函数注释，那么下面的赋值语句会提示错误，因为此时不存在只有一个age参数的构造器！
        PersonCreatorWithAge person2 = Person::new;

        PersonCreatorWithName person3 = Person::new;

        PersonCreatorAllConstruct person4 = Person::new;

    }


    public interface PersonCreatorNoConstruct {
        // 对应Person无参构造
        Person create();
    }

    public interface PersonCreatorWithAge {
        // 对应Person的age构造函数
        Person create(Integer age);
    }

    public interface PersonCreatorWithName {
        // 对应Person的name构造函数
        Person create(String name);
    }

    public interface PersonCreatorAllConstruct {
        // 对应Person的全参构造函数
        Person create(Integer age, String name);
    }

    @Getter
    @Setter
    static class Person {
        private Integer age;
        private String name;

        public Person() {
        }

        public Person(Integer age) {
            this.age = age;
        }

        public Person(String name) {
            this.name = name;
        }

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

public class MethodReferenceTest {
    public static void main(String[] args) {
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        String str1 = "abc";
        String str2 = "abcd";

        //这里不太明白为什么可以直接用string的compareTo的方法引用
        //compareString方法第三个参数要求的是Comparator类型的对象，以Lambda表达式来讲 它接受的对象对应实现的方法要求的是两个入参。
        //而String::compareTo方法只有一个入参，所以这里不太明白为什么可以直接用string的compareTo的方法引用
        compareString(str1, str2, String::compareTo);
    }

    public static void compareString(String str1, String str2, Comparator<String> comparator) {
        System.out.println(comparator.compare(str1, str2));
    }
}

java.lang.String#compareTo只接收一个入参。但是，Comparator接口的compare()方法接收两个入参。因此，当使用方法引用时，需要将第一个入参传递给this。在本例中，this指向String对象。因此，方法引用String::compareTo等效于Lambda表达式(this, o) -> this.compareTo(o)。

函数式接口

以Predicate为例，之前在分析山寨Stream API时，我们已经不知不觉使用过函数式接口：

// 1.用Lambda表达式实现Predicate接口的抽象方法test()，并赋值给函数式接口
Predicate<User> ifHigherThan180 = user -> user.getHeight()>180;
// 2.作为参数传入filter(Predicate<T> ifHigherThan180)，filter()会在内部调用test()用来判断
ifHigherThan180.test(user);

总的来说，就是把方法A（Lambda）传给方法B（filter），然后在方法B内部调用方法A完成一些操作：

public void methodB(method a) {
    // 操作1
    // 调用method a
    // 操作3
}

我们可以理解为Java8支持传递方法（之前只能传递基本数据类型和引用类型），也可以按原来面向对象的思维将Lambda理解为“特殊的匿名对象”。

为什么函数式接口重要

之前只是向大家介绍了函数式接口的定义：

有且仅有一个抽象方法的接口（不包括默认方法、静态方法以及对Object方法的重写）

就我个人学习体会来看，函数式接口虽然不难，但作为参数类型出现时，经常会让初学者感到无所适从，甚至不知道该传递什么。比如Stream API中就大量使用了函数式接口接收形参：

CompletableFuture中也大量使用了函数式接口：

不知道大家是否曾经在调用filter()、supplyAsync()等方法时感到迷茫，起码我刚接触Java8时，每次调用这些方法都力不从心，不知道该传什么进去，也不知道Lambda表达式该怎么写。

如果你问我函数式接口难吗，我大概率会告诉你，它本身很简单。但如果你问我函数式接口重要吗，我会告诉你，它非常非常重要，能否熟练使用Java8的诸多新特性（Stream、CompletableFuture等）取决于你对函数式接口的熟悉程度。

函数式接口类型

根据方法的出入参类型不同，各种排列组合后，其实有很多种类型，最常用的有以下4种函数式接口：

public class FunctionalInterfaceTest {

    /**
     * 给函数式接口赋值的格式：
     * 函数式接口 = 入参 -> 出参/制造出参的语句
     *
     * @param args
     */
    public static void main(String[] args) {
        FunctionalInterface1 interface1 = str -> System.out.println(str);
        FunctionalInterface2 interface2 = () -> {
            return "abc";
        };
        FunctionalInterface3 interface3 = str -> Integer.parseInt(str);
        FunctionalInterface4 interface4 = str -> str.length() > 3;
    }


    /**
     * 消费型，吃葡萄不吐葡萄皮：有入参，无返回值
     * (T t) -> {}
     */
    interface FunctionalInterface1 {
        void method(String str);
    }

    /**
     * 供给型，无中生有：没有入参，却有返回值
     * () -> T t
     */
    interface FunctionalInterface2 {
        String method();
    }

    /**
     * 映射型，转换器：把T转成R返回
     * T t -> R r
     */
    interface FunctionalInterface3 {
        int method(String str);
    }

    /**
     * 特殊的映射型：把T转为boolean
     * T t -> boolean
     */
    interface FunctionalInterface4 {
        boolean method(String str);
    }
}

正因为各自出入参不同，导致Lambda表达式的写法也不同。

函数式接口作用

实际开发中，出入参类型的排列组合是有限的，所以JDK干脆内置了一部分函数式接口。一般来说，我们只需熟练掌握以下4大核心函数式接口即可：

消费型接口 Consumer<T> void accept(T t)
供给型接口 Supplier<T> T get()
函数型接口 Function<T, R> R apply(T t)
断定型接口 Predicate<T> boolean test(T t)

其实是对各个方法的抽象类型

什么JDK要在Java8这个版本引入函数式接口，并且提供这么多内置接口呢？

其实这些接口本不是给我们用的，而是JDK自己要用。

之前的filter和map方法模拟：

/**
 * 新建Predicate接口
 *
 * @param <T>
 */
@FunctionalInterface
interface Predicate<T> {
    /**
     * 定义了一个test()方法，传入任意对象，返回true or false，具体判断逻辑由子类实现
     *
     * @param t
     * @return
     */
    boolean test(T t);
}

// Function接口 略...

同样的，我和Java8一样，也把Predicate接口作为形参类型（详见myPrint方法）：

public class MockStream {

    public static void main(String[] args) {

        Person bravo = new Person("bravo", 18);

        // 1.匿名对象，调用它的test()方法
        Predicate<Person> predicate1 = new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() < 18;
            }
        };
        myPrint(bravo, predicate1); // false

        // 2.Lambda表达式，调用它的test()方法。
        // 按照Lambda表达式的标准，只要你是个函数式接口，那么就可以接收Lambda表达式
        Predicate<Person> predicate2 = person -> person.getAge() == 18;
        myPrint(bravo, predicate2); // true
    }

    public static void myPrint(Person person, Predicate<Person> filter) {
        if (filter.test(person)) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

JDK之所以要在Java8内置那么多函数式接口，本质原因和我的山寨Stream API一样，是为了配合Java8的各种API。单独发布Stream API和CompletableFuture是不现实的，它们的方法形参都依赖函数式接口呢。

Java8函数式接口的作用和我们自定义的Predicate接口一样：

接收Lambda表达式/方法引用
占坑

或者说，这两个作用是一体两面的。

如何克服面向对象的思维惯性

对于函数式接口，上面已经讲得很多了，本身很简单，没什么好介绍的。这里主要聊一聊初学者应该如何习惯函数式接口传参的方式，以及关注点应该放哪里。换句话说，帮助初学者克服面向对象的思维惯性，学会用函数式编程的思维去使用Java8的诸多特性。

还是以Predicate为例，它唯一的抽象方法是：

boolean test(T t);

很多Java程序员会对这种传参形式感到眩晕，因为我们的潜意识一直无法摆脱面向对象的影响。当你看到getHealthPerson(List<User> users, Predicate<User> filter)时，你的大脑会告诉你Predicate是一个接口，所以应该传一个匿名对象给它。然后你的大脑自己也懵了，因为它突然发现光看Predicate接口，根本不知道该实现什么方法，甚至连入参和返回值都不清楚，怎么手写Lambda？

但之前介绍Python的函数时，我们很自然就接受了：

# encoding: utf-8

# abs是Python的内置函数
result = abs(-1)
print(result)

# 定义add()方法，f显然是一个函数
def add(x, y, f):
    return f(x) + f(y)

print(add(-1, -2, abs))

因为相比Python这些原本就支持函数式编程的语言来说，形参就是函数，不需要用接口做中间层过渡！而对于Stream这种面向对象世界中的异类，Java程序员还没准备好如何接纳它，看到接口形参第一时间想到的还是传匿名对象，突然要改成Lambda确实有点棘手，因为我们对接口内部的方法及出入参一概不知！

每个函数式接口就一个方法，记住那个方法的出入参，看到接口就写对应方法的Lambda

这里主要讲讲如何记忆函数式接口的方法。一定要注意，函数式接口的方法名字不重要，重要的是出入参：

消费型接口 Consumer<T> void accept(T t) 例：x -> System.out.println(x)
供给型接口 Supplier<T> T get() 例：() ->
函数型接口 Function<T, R> R apply(T t) 例：user -> user.getAge()，T是入参，R是出参
断定型接口 Predicate<T> boolean test(T t) 例：user -> user.getAge() > 18

记住了接口对应的出入参，Lambda就好办了，其实传递的都是：

接口声明 = 入参 -> 出参/制造出参的语句

不信你可以重新看看上面给出的例子，比如Function：user -> user.getAge()，就是把User user映射为Integer age，user是入参，user.getAge()是制造出参的语句。又比如Predicate：user -> user.getAge()>18，user是入参，user.getAge()>18就是制造出参的语句，因为boolean test(T t)需要返回boolean。

所以要习惯函数式接口传参，最重要的是记住该接口对应的方法的出入参，然后编写Lambda时套用模板：

接口声明 = 入参（有无入参？） -> 出参/制造出参的语句（有无出参？什么类型？）

虽然我们还没正式学习Stream API，但已经可以试着写写啦：

public class FunctionalInterfaceTest {

    public static void main(String[] args) {

        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));

        /**
         * Predicate：特殊映射，只断是非   Function：T t --> f(x) --> boolean
         * Function：映射               Function：T t --> f(x) --> R r
         */
        list.stream().filter().map().collect(Collectors.toList());

        // Supplier，无源之水(S)，却滔滔不绝，没有入参，却可以get()
        CompletableFuture<Object> completableFuture = CompletableFuture.supplyAsync();

        // Consumer，黑洞，吃(C)葡萄不吐葡萄皮，入参拿过来就是一顿操作，不返回
        completableFuture.thenAccept();

    }

}

函数式接口与类型推断

之前在《Lambda表达式》中，我举过一个例子

当接口内只有一个抽象方法时，可以使用Lambda表达时给接口赋值：

MyInterface interface = () -> System.out.println("吃东西")；

但如果函数式接口内有多个方法抽象方法，就无法传递Lambda表达式：

此时只能传入匿名对象分别实现两个抽象方法：

学完这一章，相信大家会有更深刻的理解：

public void run()和public void eat()如果只看出入参，其实是一样的，所以编译时无法自动推断。

由于本章节一直在强调函数式接口传参，所以这里再给出一个例子：

public class FunctionalInterfaceTest {

    public static void main(String[] args) {
		// Ambiguous method call
        lambdaMethod(() -> System.out.println("test"));
    }

    /**
     * 方法重载
     *
     * @param param1
     */
    public static void lambdaMethod(Param1 param1) {
        param1.print();
    }

    /**
     * 方法重载
     *
     * @param param2
     */
    public static void lambdaMethod(Param2 param2) {
        param2.print();
    }

    /**
     * 函数式接口1
     */
    interface Param1 {
        void print();
    }

    /**
     * 函数式接口2
     */
    interface Param2 {
        void print();
    }

}

原因也是一样的，Lambda只关注方法的出入参，所以在进行类型推断时，interface Param1和interface Param2是一样的，编译器无法替我们决定实现哪一个接口，解决办法是使用匿名对象。

如果说《Lambda表达式》中举的例子是方法级别的推断冲突，那么上面的例子讲的就是接口级别的推断冲突，但归根结底就一句话：Lambda上下文推断只看出入参，无论是接口名还是方法名，都不重要！

所以，学习函数式接口最重要的就是记住出入参的格式！！

参照附：ConvertUtil.java

小试牛刀

实际开发中，经常会看到这样的写法：

public void XxMethod(){
    
    // ...
    
    List<Long> iidList = new ArrayList<>();
    List<Long> eventList = new ArrayList<>();
    if(items != null && items.size > 0) {
        for(Item item : items){
            iidList.add(item.getId());
            eventList.add(item.getEvent());
        }
    }
    
    // ...
}

public void XxMethod(){
    
    // ...
    
    List<Long> iidList = new ArrayList<>();
    List<Long> eventList = new ArrayList<>();
	List<xxx> xxxList = new ArrayList<>();
	...

	//对iidList和eventList和其他List的其他操作

    if(items != null && items.size > 0) {
        for(Item item : items){
            iidList.add(item.getId());
            eventList.add(item.getEvent());
            xxxList.add(...);
            ....
        }
    }
    
    // ...
}

这里能用ConvertUtil的resultToList()吗？

答案是，不能。resultToList()一次只处理一个List，而上面一次循环可能处理N个List。所以我们能做的，只是抽取循环的操作，具体循环里做什么，每个List可能不同，不好抽取。

有了上面的经验，我们完全可以再给ConvertUtil封装个方法：

/**
 * foreach，内部判空
 *
 * @param originList 需要遍历的List
 * @param processor  需要执行的操作
 * @param <T>
 */
public static <T> void foreachIfNonNull(List<T> originList, Consumer<T> processor) {
    if (originList == null || originList.isEmpty()) {
        return;
    }
    for (T originElement : originList) {
        if (originElement != null) {
        	processor.accept(originElement);
        }
    }
}

public void XxMethod(){
    
    // ...
    
    List<Long> iidList = new ArrayList<>();
    List<Long> eventList = new ArrayList<>();
    ConvertUtil.foreachIfNonNull(items, item -> {
         iidList.add(item.getId());
         eventList.add(item.getEvent());
    })
    
    // ...
}

上面相当于自己实现了foreach。你可能会想，为什么不直接用Stream API或者直接List.foreach()？原因在于它们都要额外判断非空，否则可能引发NPE。

实际上这个操作也是可以完全抽取的，只是利用了前文中泛型擦除的特性：

public static <T,R> void add(List<T> baseList, List[] lists, Function<T,R> ... functions){  
    for (T t : baseList) {  
        for (int i = 0; i < lists.length; i++) {  
            lists[i].add(functions[i].apply(t));  
        }  
    }  
}

虽然存入的时候按照Object存入（实际上也是利用了这个特性才能完成这个操作），取出的时候因为声明的泛型可以转换为对应的类型

最后留个思考题：自己实现groupBy()。

public static <T, K> Map<K, List<T>> groupBy(List<T> originList, Function<T, K> keyExtractor) {  
    HashMap<K, List<T>> hashMap = new HashMap<>();  
    for (T t : originList) {  
        if (t != null){  
            K key = keyExtractor.apply(t);  
            if (hashMap.get(key) == null) {  
                ArrayList<T> tList = new ArrayList<>();  
                tList.add(t);  
                hashMap.put(key,tList);  
            }else {  
                hashMap.get(key).add(t);  
            }  
        }  
    }  
    return hashMap;  
}

如果分组后，我要的不是Map(City, List(User))，而是Map(City, List(username))呢？你能基于上面的方法进行改造吗？

public static <T,K,R> Map<K, List<R>> groupBy(List<T> originList, Function<T, K> keyExtractor, java.util.function.Function<T,R> mapper) {  
    HashMap<K, List<R>> hashMap = new HashMap<>();  
    for (T t : originList) {  
        if (t != null){  
            K key = keyExtractor.apply(t);  
            if (hashMap.get(key) == null) {  
                ArrayList<R> rList = new ArrayList<>();  
                rList.add(mapper.apply(t));  
                hashMap.put(key,rList);  
            }else {  
                hashMap.get(key).add(mapper.apply(t));  
            }  
        }  
    }  
    return hashMap;  
}

Stream

获取Stream流

获取Stream流：

获取方式	方法名	说明
单列集合	`default Stream<E> stream()`	Collection接口的默认方法
双列集合	无	无法直接使用Stream流
数组	`public static <T> Stream<T> stream(T[] array)`	Arrays工具类中的静态方法
一堆零散数据	`public static <T> Stream<T> of(T ...values)`	Stream接口中的静态方法

单列集合

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e");

//获取流并将集合中的数据放上去
Stream<String> stream1 = list.stream();

//使用终结方法打印
stream1.forEach(s -> System.out.println(s));

双列集合

HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa",111);
hm.put("bbb",222);
hm.put("ccc",333);
hm.put("ddd",444);

hm.keySet().stream().forEach(s->{
	System.out.println(s + " : " + hm.get(s));
});

hm.entrySet().stream().forEach(e ->{
	System.out.println(e.getKey() + " : " + e.getValue());
});

数组

int[] arr = {1,2,3,4,5,6,7,8,9,10};
String[] strs = {"a","b","c"};

Arrays.stream(arr).forEach(s-> System.out.println(s));
Arrays.stream(strs).forEach(s-> System.out.println(s));

零散数据

//stream流中元素是Integer类型
Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));
//stream流中元素是String类型
Stream.of("1","2","3","4","5").forEach(s-> System.out.println(s));

//stream流中元素是Serializable类型
Stream.of(1, 3, "a").forEach(s-> System.out.println(s));

不建议使用Stream.of方法创建数组的Stream流，引用数据类型的数组没有问题，基本数据类型的数组就会出现以下问题：

//引用类型数组  
String[] strs = {"a","b","c"};  
//Stream.of获取引用类型的数组没有问题，输出：abc  
Stream.of(strs).forEach(System.out::print);  
  
//基本类型数组  
int[] ints = {1,2,3};  
//Stream.of获取基本类型的数组出现问题，输出：[I@21e360a  
Stream.of(ints).forEach(System.out::print);

对于基本类型数组，Stream.of会将整个数组当作一个元素放在Stream流上。

接口默认、静态方法

之前学习函数式接口时，曾经提到过Java8新出的接口静态方法、默认方法：

为什么Java8要引入静态方法和默认方法呢？

原因可能有多种，但其中一种肯定是为了“静默升级”。打开Collection接口：

这下明白了吧，list.stream().filter()...用的这么爽，其实都直接继承自顶级父接口Collection。

这和引入default有啥关系呢？

试想一下，要想操作Stream必须先获取Stream，获取流的方法理应放在Collection及其子接口、实现类中。但如果作为抽象方法抽取到Collection中，那么原先的整个继承链都会产生较大的震动：

JDK官方要从Collection接口沿着继承链向下都实现一遍stream()方法。这还不是最大的问题，最致命的是全球各地保不齐就有人直接实现了Collection，比如MyArrayList啥的，此时如果贸然往Collection增加一个抽象方法，那么当他们升级到JDK1.8后就会立即编译错误，强制他们自己实现stream()...

所以JDK的做法是，把获取Stream的一部分方法封装到StreamSupport类，另一部分封装到Stream类，StreamSupport用来补足原先的集合体系，比如Collection，然后引入default方法包装一下，内部调用StreamSupport完成偷天换日。而得到Stream后的一系列filter、map操作是针对Stream的，已经封装在Stream类中，和原来的集合无关。

所以，StreamSupport+default就是原先集合体系和Stream之间的“中介”：

调用者-->Collection-->StreamSupport+default-->Stream

总之，引入接口默认方法和静态方法后，接口越来越像一个类。从某个角度来说，这种做法破坏了Java的单继承原则。Java原本的特点是“单继承、多实现”，假设接口A和接口B都有methodTest()，那么class Test implements interfaceA, interfaceB时，就不得不考虑使用哪个父接口的methodTest()方法。JDK的做法是，编译时强制子类覆盖父接口同名的方法。

Stream API

我们最常用的集合其实来自两个派系：Collection和Map，实际开发时使用率大概是这样的：

ArrayList：50%
HashMap：40%
其他：10%

而用到Stream的地方，占比就更极端了：

List：90%
Set：5%
Map：5%

对于一般人来说，只要学好List的Stream用法即可。

认识几个重要的接口与类

Stream的方法众多，不要期望能一次性融会贯通，一定要先了解整个API框架。有几个很重要的接口和类：

Collection
Stream
StreamSupport
Collector
Collectors

Collection

之前介绍过了，为了不影响之前的实现，JDK引入了接口默认方法，并且在Collection中提供了一系列将集合转为Stream的方法：

要想使用Stream API，第一步就是获取Stream，而Collection提供了stream()和parallelStream()两个方法，后续Collection的子类比如ArrayList、HashSet等都可以直接使用顶级父接口定义好的默认方法将自身集合转为Stream。

Collection：定义stream()/parallelStream()
    |--List
        |--ArrayList：list.stream().filter().map().collect(...)
        |--LinkedList：list.stream().filter().map().collect(...)
        |--Vector
    |--Set
        |--HashSet
        |--TreeSet

Stream

Java的集合在设计之初就只是一种容器，用来存储元素，内部并没有提供处理元素的方法。更多时候，我们其实是使用集合提供的遍历方法，然后手动在外部进行判断并处理元素。

Stream是什么呢？简单来说，可以理解为更高级的Iterator，把集合转为Stream后，我们就可以使用Stream对元素进行一系列操作

平时使用的filter()、map()、sorted()、collect()都来自：

方法太多了，记忆时需要带点技巧，比如分类记忆。

常用的有两种分类方法：

终止/中间操作
短路/非短路操作

前一种分类和我们关系大一些，所以我们按终止、中间操作分类记忆。

所谓中间操作和终止操作，可以粗略地理解为后面还能不能跟其他的方法。比如filter后面还可以跟map等操作，那么filter就是中间操作，而collect后返回的就是元素了，而不是流，无法继续使用。就好比一缕山泉，经过小草、小花、竹林，还是一缕水，但到了你的锅里煮成一碗粥，就没法继续使用了。

思维导图占位

还有几个不是特别常用的操作就不放在思维导图里了，这里简要介绍一下。比如，除了Collection接口中定义的stream()和parallelStream()，Stream也定义了创建流的方法（不常用）：

还有一个合并流的方法（知道即可）：

StreamSupport

没啥好介绍的，一般不会直接使用StreamSupport，Collection接口借助它实现了stream()和parallelStream()。

collect()、Collector、Collectors

直接演示：

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("甲", 18, "杭州", 999.9));
        list.add(new Person("乙", 19, "温州", 777.7));
        list.add(new Person("丙", 21, "杭州", 888.8));
        list.add(new Person("丁", 17, "宁波", 888.8));

    }

    public static void main(String[] args) {
        List<Person> result = list.stream()
                .filter(person -> person.getAge() > 20)
                .collect(Collectors.toList());
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }

}

collect()是用来收集处理后的元素的，它有两个重载的方法：

我们暂时只看下面那个，它接收一个Collector对象，而我们一般不会自己去new Collector对象，因为JDK给我提供了Collectors，可以调用Collectors提供的方法返回Collector对象：

所以collect()、Collector、Collectors三者的关系是：

collect()通过传入不同的Collector对象来明确如何收集元素，比如收集成List还是Set还是拼接字符串，而通常我们不需要自己实现Collector接口，只需要通过Collectors获取。

这倒颇有点像Executor和Executors的关系，一个是线程池接口，一个是线程池工具类。

如何高效学习Stream API

和几个重要接口、类混个脸熟后，我们来谈谈如何高效学习Stream API。很多同学应该已经被上面的内容吓到了，不要怕，通过后面的实操，整个知识脉络很快就会清晰起来。但还是那句话，一开始不要扣细节，先抓主干

Stream API.png

初学者如果对stream的流式操作感到陌生，可以暂时理解为外部迭代（实际不是这样的，后面会大家一起观察）：

特别注意reduce()：

特别适合做累加、累乘啥的。

铺垫结束，接下来我们通过实战来正式学习Stream API。学习其他技术都可以追求理论深度，唯独Stream API就是一个字：干！

基础操作

map/filter

先来个最简单：

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // 我们先学中间操作

        // 1.先获取流（不用管其他乱七八糟的创建方式，记住这一个就能应付95%的场景）
        Stream<Person> stream = list.stream();
        // 2.过滤得到年纪大于18岁的（filter表示过滤【得到】符合传入条件的元素，而不是过滤【去除】）
        Stream<Person> filteredByAgeStream = stream.filter(person -> person.getAge() > 18);
        // 3.只要名字，不需要整个Person对象（为什么在这个案例中，filter只能用Lambda，map却可以用方法引用？）
        Stream<String> nameStream = filteredByAgeStream.map(Person::getName);
        // 4.现在返回值是Stream<String>，没法直接使用，帮我收集成List<String>
        List<String> nameList = nameStream.collect(Collectors.toList());
        
        // 现在还对collect()为什么传递Collectors.toList()感到懵逼吗？
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

sorted()

试着加入sorted()玩一下。

在此之前，我们先来见见一位老朋友：Comparator。这个接口其实早在JDK1.2就有了，但当时只有两个方法：

compare()
equals()

JDK1.8通过默认方法的形式引入了很多额外的方法，比如reversed()、comparing()等。

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // JDK8之前：Collections工具类+匿名内部类。Collections类似于Arrays工具类，我经常用Arrays.asList(）
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getName().length()-p2.getName().length();
            }
        });
        
        // JDK8之前：List本身也实现了sort()
        list.sort(new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getName().length()-p2.getName().length();
            }
        });
        
        // JDK8之后：Lambda传参给Comparator接口，其实就是实现Comparator#compare()。注意，equals()是Object的，不妨碍
        list.sort((p1,p2)->p1.getName().length()-p2.getName().length());
        
        // JDK8之后：使用JDK1.8为Comparator接口新增的comparing()方法
        list.sort(Comparator.comparingInt(p -> p.getName().length()));
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

大家不好奇吗？sort()需要的是Comparator接口的实现，调用Comparator.comparingInt()怎么也可以？

传入一个转换器，将key转换为Integer，不传入比较规则的都是按照升序排列的

重点：Comparator.comparingXxx()返回的也是Comparator，comparingXxx()方法其实都来源于comparing方法：

该方法接收一个比较器，在比较器中比较两个经过mapper转换的数据，比较的规则就是compare方法的方法体，例如：

Comparator<Object> comparing =
		Comparator.comparing(person -> ((Person) person).getAge(), (age1, age2) -> age1 - age2);

所以上文中对List按照年龄升序排列也可以写为：

list.sort(Comparator.comparing(Function.identity(),Comparator.comparingInt(Person::getAge)));

OK，铺垫够了，来玩一下Stream#sorted()，看看和List#sort()有啥区别。

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // 直接链式操作
        List<String> nameList = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .collect(Collectors.toList());
        System.out.println(nameList);

        // 我想按姓名长度排序
        List<String> sortedNameList = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .sorted()
                .collect(Collectors.toList());
        System.out.println(sortedNameList);

        // 你：我擦，说好的排序呢？

        // Stream：别扯淡，你告诉我排序规则了吗？（默认自然排序）

        // 明白了，那就按照长度倒序吧（注意细节啊，str2-str1才是倒序）
        List<String> realSortedNameList = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .sorted((str1, str2) -> str2.length() - str1.length())
                .collect(Collectors.toList());
        System.out.println(realSortedNameList);

        // 优化一下：我记得在之前那张很大的思维导图上看到过，sorted()有重载方法，是sorted(Comparator)
        // 上面Lambda其实就是调用sorted(Comparator)，用Lambda给Comparator接口赋值
        // 但Comparator还供了一些方法，能返回Comparator实例
        List<String> optimizeNameList = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList());
        System.out.println(optimizeNameList);

        // 又是一样的套路，Comparator.reverseOrder()返回的其实是一个Comparator！！

        // 但上面的有点投机取巧，来个正常点的，使用Comparator.comparing()
        List<String> result1 = list.stream()
                .filter(person -> person.getAge() > 18)
                .map(Person::getName)
                .sorted(Comparator.comparing(t -> t, (str1, str2) -> str2.length() - str1.length()))
                .collect(Collectors.toList());
        System.out.println(result1);

        // 我去，更麻烦了！！
        // 不急，我们先来了解上面案例中Comparator的两个参数
        // 第一个是Function映射，就是指定要排序的字段，由于经过上一步map操作，已经是name了，就不需要映射了，所以是t->t
        // 第二个是比较规则
        
        // 我们把map和sorted调换一下顺序，看起来就不那么别扭了
        List<String> nameList = list.stream()  
        .filter(person -> person.getAge() > 18)  
        .sorted(Comparator.comparing(Person::getName,(str1,str2) -> str2.length() - str1.length()))  
        .map(Person::getName)  
        .collect(Collectors.toList());  
		System.out.println(nameList);

		//但是想实现倒序排列，还可以这样做：
        List<String> result2 = list.stream()
                .filter(person -> person.getAge() > 18)
                .sorted(Comparator.comparing(Person::getName, String::compareTo).reversed())
                .map(Person::getName)
                .collect(Collectors.toList());
        System.out.println(result2);

        // 为什么Comparator.comparing().reversed()可以链式调用呢？
        // 上面说了哦，因为Comparator.comparing()返回的还是Comparator对象~
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

需要注意的是：

Comparator.comparing(Person::getName, String::compareTo)

进行升序排列，如果要降序可以自定义，或者可以在升序排列后再链式调用reverse方法，该方法：

会将当前元素反转

limit/skip

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        List<String> result = list.stream()
                .filter(person -> person.getAge() > 17)
                // peek()先不用管，它不会影响整个流程，就是打印看看filter操作后还剩什么元素
                .peek(person -> System.out.println(person.getName()))
                .skip(1)
                .limit(2)
                .map(Person::getName)
                .collect(Collectors.toList());
        System.out.println(result);
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

结果

==== 过滤后的元素有3个 ====

i

am

iron

==== skip(1)+limit(2)后的元素 ====

[am, iron]

collect

collect()是最重要、最难掌握、同时也是功能最丰富的方法。

最常用的4个方法：Collectors.toList()、Collectors.toSet()、Collectors.toMap()、Collectors.joining()

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // 最常用的4个方法

        // 把结果收集为List
        List<String> toList = list.stream().map(Person::getAddress).collect(Collectors.toList());
        System.out.println(toList);
        
        // 把结果收集为Set
        Set<String> toSet = list.stream().map(Person::getAddress).collect(Collectors.toSet());
        System.out.println(toSet);
        
        // 把结果收集为Map，前面的是key，后面的是value，如果你希望value是具体的某个字段，可以改为toMap(Person::getName, person -> person.getAge())
        Map<String, Person> nameToPersonMap = 
	        list.stream().collect(Collectors.toMap(Person::getName, person -> person));
        System.out.println(nameToPersonMap);

        // 把结果收集起来，并用指定分隔符拼接
        String result = list.stream().map(Person::getAddress).collect(Collectors.joining("~"));
        System.out.println(result);
    }
}

关于collect收集成Map的操作，有一个小坑需要注意：

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("iron", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        Map<String, Person> nameToPersonMap = 
	        list.stream().collect(Collectors.toMap(Person::getName, person -> person));
        System.out.println(nameToPersonMap);
    }
}

尝试运行上面的代码，会观察到如下异常：

Exception in thread "main" java.lang.IllegalStateException: Duplicate key Person

这是因为toMap()不允许key重复，我们必须指定key冲突时的value解决策略（比如，保留已存在的value）

public static void main(String[] args) {
    Map<String, Person> nameToPersonMap = 
			list.stream()
            .collect(Collectors.toMap(Person::getName, person -> person, (preValue, nextValue) -> preValue));
    System.out.println(nameToPersonMap);
}

如果你希望key覆盖，可以把(preKey, nextKey) -> preKey)换成(preKey, nextKey) -> nextKey)。

你可能会在同事的代码中发现另一种写法：

public static void main(String[] args) {
    Map<String, Person> nameToPersonMap = 
			    list.stream().collect(Collectors.toMap(Person::getName, Function.identity());
    System.out.println(nameToPersonMap);
}

Function.identity()其实就是v->v：

但它依然没有解决key冲突的问题，而且对于大部分人来说，相比person->person，Function.identity()的可读性不佳。

聚合：max/min/count

max/min

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
		// 匿名内部类的方式，实现Comparator，明确按什么规则比较（所谓最大，必然是在某种规则下的最值）  
		//Optional<Integer> maxAge = 
		//             		list.stream().map(Person::getAge).max((age1,age2) -> age1 - age2);  
		
		Optional<Integer> maxAge = 
					list.stream().map(Person::getAge).max(Comparator.comparingInt(age -> age));  
		System.out.println(maxAge.orElse(0));  
		  
		Optional<Integer> max = list.stream().map(Person::getAge).max(Integer::compareTo);  
		System.out.println(max.orElse(0));
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

count

public static void main(String[] args) {
    long count = list.stream().filter(person -> person.getAge() > 18).count();
    System.out.println(count);
}

去重：distinct

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        long count = list.stream().map(Person::getAddress).distinct().count();
        System.out.println(count);
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

所谓“去重”，就要明确怎样才算“重复”。那么，distinct()是基于什么标准呢？

还是那两样：hashCode()和equals()，所以记得重写这两个方法（一般使用Lombok的话问题不大）。

distinct()提供的去重功能比较简单，就是判断对象重复。如果希望实现更细粒度的去重，比如根据对象的某个属性去重，可以参考：分享几种 Java8 中通过 Stream 对列表进行去重的方法

forEach

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    public static void main(String[] args) {
        // 遍历操作，接收Consumer
        list.stream().forEach(System.out::println);
        // 简化，本质上不算同一个方法的简化
        list.forEach(System.out::println);
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

需要的就是一个Consumer参数

高阶操作

两部分内容：

深化一下collect()方法，它还有很多其他玩法
介绍flatMap、reduce、匹配查找、peek、forEach等边角料

collect高阶操作

聚合

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    /**
     * 演示用collect()方法实现聚合操作，对标max()、min()、count()
     * @param args
     */
    public static void main(String[] args) {
        // 方式1：匿名对象
        Optional<Person> max1 = list.stream().collect(Collectors.maxBy(new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getAge() - p2.getAge();
            }
        }));
        System.out.println(max1.orElse(null));

        // 方式2：Lambda
        Optional<Person> max2 = 
			        list.stream().collect(Collectors.maxBy((p1, p2) -> p1.getAge() - p2.getAge()));
        System.out.println(max2.orElse(null));

        // 方式3：方法引用
        Optional<Person> max3 = 
			        list.stream().collect(Collectors.maxBy(Comparator.comparingInt(Person::getAge)));
        System.out.println(max3.orElse(null));
	    //Optional<Person> max1 = 
//list.stream().collect(Collectors.maxBy(Comparator.comparing(Person::getSalary,Double::compareTo)));

        // 方式4：IDEA建议直接使用 max()，不要用 collect(Collector)
        Optional<Person> max4 = list.stream().max(Comparator.comparingInt(Person::getAge));
        System.out.println(max4.orElse(null));
        
        // 特别是方式3和方式4，可以看做collect()聚合和max()聚合的对比
        
        // 剩下的minBy和counting

        Optional<Person> min1 = 
			        list.stream().collect(Collectors.minBy(Comparator.comparingInt(Person::getAge)));
        Optional<Person> min2 = list.stream().min(Comparator.comparingInt(Person::getAge));

        Long count1 = list.stream().collect(Collectors.counting());
        Long count2 = list.stream().count();
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

分组

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    /**
     * 按字段分组
     * 按条件分组
     *
     * @param args
     */
    public static void main(String[] args) {
        // GROUP BY address
        Map<String, List<Person>> groupingByAddress = 
        list.stream().collect(Collectors.groupingBy(Person::getAddress));
        System.out.println(groupingByAddress);

        // GROUP BY address, age
        Map<String, Map<Integer, List<Person>>> doubleGroupingBy = list.stream()
                .collect(Collectors.groupingBy(Person::getAddress, Collectors.groupingBy(Person::getAge)));
        System.out.println(doubleGroupingBy);

        // 简单来说，就是collect(groupingBy(xx)) 扩展为 collect(groupingBy(xx, groupingBy(yy)))，嵌套分组

        // 解决了按字段分组、按多个字段分组，我们再考虑一个问题：有时我们分组的条件不是某个字段，而是某个字段是否满足xx条件
        // 比如 年龄大于等于18的是成年人，小于18的是未成年人
        Map<Boolean, List<Person>> adultsAndTeenagers = list.stream().collect(Collectors.partitioningBy(person -> person.getAge() >= 18));
        System.out.println(adultsAndTeenagers);
    }
    
   @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

提一句，collect()方法是最为丰富的，可以搭配Collector玩出很多花样，特别是经过各种嵌套组合。本文末尾留了几道思考题，大家到时可以试着做做。

统计

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("man", 17, "宁波", 888.8));
    }

    /**
     * 统计
     * @param args
     */
    public static void main(String[] args) {
        // 平均年龄
        Double averageAge = list.stream().collect(Collectors.averagingInt(Person::getAge));
        System.out.println(averageAge);

        // 平均薪资
        Double averageSalary = list.stream().collect(Collectors.averagingDouble(Person::getSalary));
        System.out.println(averageSalary);
        
        // 其他的不演示了，大家自己看api提示。简而言之，就是返回某个字段在某个纬度的统计结果
        
        // 有个更绝的，针对某项数据，一次性返回多个纬度的统计结果：总和、平均数、最大值、最小值、总数，但一般用的很少
        IntSummaryStatistics allSummaryData = list.stream().collect(Collectors.summarizingInt(Person::getAge));
        long sum = allSummaryData.getSum();
        double average = allSummaryData.getAverage();
        int max = allSummaryData.getMax();
        int min = allSummaryData.getMin();
        long count = allSummaryData.getCount();
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
    }
}

flatMap

总的来说，就是flatMap就是把多个流合并成一个流：

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9, new ArrayList<>(Arrays.asList("成年人", "学生", "男性"))));
        list.add(new Person("am", 19, "温州", 777.7, new ArrayList<>(Arrays.asList("成年人", "打工人", "宇宙最帅"))));
        list.add(new Person("iron", 21, "杭州", 888.8, new ArrayList<>(Arrays.asList("喜欢打篮球", "学生"))));
        list.add(new Person("man", 17, "宁波", 888.8, new ArrayList<>(Arrays.asList("未成年人", "家里有矿"))));
    }

    public static void main(String[] args) {
        Set<String> allTags = 
        list.stream().flatMap(person -> person.getTags().stream()).collect(Collectors.toSet());
        System.out.println(allTags);
    }
    

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;
        // 个人标签
        private List<String> tags;
    }
}

对于每个Person对象中的tags，如果没有flatMap，想要合并去重会比较麻烦。

对比map和flatMap：

flatMap传入的Function要求返回值是Stream<? extends R>而不是R，所以上面写的是：

map是将对象的类型转换，flatMap是将对象的成员属性变为流，集合中的多个流合并为一个流。

去重也可以：

List<String> allTags = list.stream().flatMap(person -> person.getTags().stream()).distinct().toList();  
System.out.println(allTags);

总之，当你遇到List中还有List，然后你又想把第二层的List都拎出来集中处理时，就可以考虑用flatMap()，先把层级打平，再统一处理。

peek()

它接受一个Consumer，一般有两种用法：

设置值
观察数据

设置值的用法：

public class StreamTest {
    public static void main(String[] args) {
        list.stream().peek(person -> person.setAge(18)).forEach(System.out::println);
    }
}

也就是把所有人的年龄设置为18岁。

peek这个单词本身就带有“观察”的意思。

简单来说，就是查看数据，一般实际开发很少用，但可以用来观察数据的流转：

public class StreamTest {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.peek(v-> System.out.print(v+","))
				        .map(value -> value + 100)
				        .peek(v-> System.out.print(v+","))
					    .forEach(System.out::println);
    }
    
}

结果

1,101,101

2,102,102

3,103,103

有没有感到好奇？

用图表示的话，就是这样：

通过peek，我们观察到每一个元素都是逐个通过Stream流的。

为了看得更清楚些，重新写个demo：

public static void main(String[] args) {
    Stream.of(1, 2, 3, 4)
            .peek(v -> System.out.print(v + ","))
            .filter(v -> v >= 2)
            .peek(v -> System.out.print(v + ","))
            .filter(v -> v >= 3)
            .forEach(System.out::println);
            //1,2,2,3,3,3
            //4,4,4
}

结果

1,2,2,3,3,3

4,4,4

这打印，怎么这么诡异？

其实不诡异，元素确实是逐个通过的：

一个元素如果中途被过滤，就不会继续往下，换下一个元素。最终串起来，就会打印：

1,2,2,3,3,3

4,4,4

大家思考一下，真正的Stream和我们之前山寨的Stream，遍历时有何不同？能画图解释一下吗？

元素一个个通过关卡

元素一起通过一个个关卡

匹配、查找

findFirst

public static void main(String[] args) {
    Optional<Integer> first = Stream.of(1, 2, 3, 4)
            .peek(v -> System.out.print(v + ","))
            .findFirst();
}

结果：

只要第一个，后续元素不会继续遍历。找到的元素在Optional中

findAny

public static void main(String[] args) {
    Optional<Integer> any = Stream.of(1, 2, 3, 4)
            .peek(v -> System.out.print(v + ","))
            .findAny();
}

结果：

findFirst和findAny几乎一样，但如果是并行流，结果可能不一致：

并行流颇有种“分而治之”的味道（底层forkjoin线程池），将流拆分并行处理，能较大限度利用计算资源，提高工作效率。但要注意，如果当前操作对顺序有要求，可能并不适合使用parallelStream。比如上图右边，使用并行流后返回的可能是4而不是1。

关于findFirst()和findAny()有没有人觉得这方法很傻逼？其实是我demo举的不对，通常来说应该是一堆filter操作任取一个等场景下使用。比如list.stream().filter(student->student.getAge()>18).findFirst()，即符合条件的任选一个。

allMatch

public static void main(String[] args) {
    boolean b = Stream.of(1, 2, 3, 4)
        .peek(v -> System.out.print(v + ","))
        .allMatch(v -> v > 2);
}

结果

由于是要allMatch，第一个就不符合，那么其他元素也就没必要测试了。这是一个短路操作。

就好比：

if(0>1 && 2>1){
    // 2>1 不会被执行，因为0>1不成立，所以2>1被短路了
}

noneMatch

public static void main(String[] args) {
    boolean b = Stream.of(1, 2, 3, 4)
            .peek(v -> System.out.print(v + ","))
            .noneMatch(v -> v >= 2);
}

结果

1,2,

和allMatch一样，它期望的是没有一个满足，而2>=2已经false，后面元素即使都大于2也不影响最终结果：noneMatch=false，所以也是个短路操作。

anyMatch

略

reduce

略，实际开发没用过，大家可以在熟悉上面的用法后再去了解，否则可能比较乱。

Stream API的效率问题

代码见附件：StreamTimeTest.java

大家把测试案例拷贝到本地test包下运行看看，相信心中有判断。虽然上面的案例中没有测试list.stream.filter().map.dictinc()等连环操作，但结果应该差不多。

但我想说的是，绝大部分时候代码的可读性应该优先于性能，况且Stream API性能并不差。和传统代码相比，Stream API让程序员专注于实现的步骤而不是细节，大大提高了代码的可读性。

Integer minPrice = itemSkuPriceTOS.stream()
                .sorted(Comparator.comparingLong(ItemSkuPriceTO::getPrice)) // 先正序排列
                .findFirst()                              // 找到第一个，也就是价格最低的item
                .map(ItemSkuPriceTO::getPrice)                              // 得到item的价格
                .orElse(0);                                                 // 兜底处理

如果你习惯了Stream API，上面的代码在可读性上会比用for循环实现好得多，所以能用Stream API的尽量用Stream API吧。毕竟上面测试用了1000w数据差距也就几十毫秒，更别说实际项目中可能就几十条了。

Stream API练习

实验数据：

public class StreamTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, "杭州", 999.9));
        list.add(new Person("am", 19, "温州", 777.7));
        list.add(new Person("iron", 21, "杭州", 888.8));
        list.add(new Person("iron", 17, "宁波", 888.8));
    }
    
    public static void main(String[] args) {
        
    }
    
    @Getter
    @Setter
    @AllArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private String address;
        private Double salary;

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", address='" + address + '\'' +
                    ", salary=" + salary +
                    '}';
        }
    }
}

map

获取所有的Person的名字

List<String> personNames = list.stream().map(Person::getName).collect(Collectors.toList());  
System.out.println(personNames);

获取一个List，每个元素的内容为：{name}来自{address}

List<String> nameFromAddress = list.stream().map(person -> person.getName() + "来自" + person.getAddress()).collect(Collectors.toList());  
System.out.println(nameFromAddress);

filter

过滤出年龄大于等于18 并且月薪大于等于888.8 并且来自杭州的Person

// 一般写法（这个filter，完全就是强迫别人花时间从头到尾阅读你代码里的细节，而且毫无提示！）
public static void main(String[] args) {
    List<Person> personList = list.stream()
            .filter(person -> (person.getAge() >= 18 && person.getSalary() > 888.8 && "杭州".equals(person.getAddres()))
            .collect(Collectors.toList());
    System.out.println(personList);
}

// 较好的写法：当我们需要给filter()、map()等函数式接口传递Lambda参数时，逻辑如果很复杂，最好抽取成方法，优先保证可读性
public static void main(String[] args) {
    List<Person> personList = list.stream()
            .filter(StreamTest::isRichAdultInHangZhou) // 改为方法引用，见名知意，隐藏琐碎的细节
            .collect(Collectors.toList());
    System.out.println(personList);
}

/**
 * 是否杭州有钱人
 *
 * @param person
 * @return
 */
private static boolean isRichAdultInHangZhou(Person person) {
    return person.getAge() >= 18
            && person.getSalary() > 888.8
            && "杭州".equals(person.getAddres());
}

统计

获取年龄的min、max、sum、average、count。

很多人看到这个问题，会条件反射地想到先用map()把Person降到Age纬度，然后看看有没有类似min()、max()等方法，思路很合理。

然后会发现：map()后只提供了max()、min()和count()三个方法（且max、min需要传递Comparator对象），没有average()和sum()。

为什么会设计得这么“麻烦”且看起来这么不合理呢？

Stream作为接口，首要任务是保证方法通用性。由于Stream需要处理的元素是不确定的，这次是Integer，下次可能是String，甚至是自定义的Person，所以要使用Stream计算min、max时，必须告诉它“怎样才是最大”、“怎样才是最小”，具体到代码里就是策略模式，需要我们传入比较规则，也就是Comparator对象。

这其实是很合理的，比如当我们把两个人进行比较时，其实都是基于某一个/某一组评判标准的，比如外貌方面，我比吴彦祖帅，或者从身高来看，我比姚明高。所有的比较结果，必须在某一个比较规则之下才成立、才有意义。

至于sum()和average()，Stream干脆没定义...这又是为什么？你想想，如果map()后得到的是name，对于字符类型来说sum()和average()是没有意义的，因为你也说不出一串名字的平均值代表着什么。也就是说sum()和average()不是通用的，不应该定义在Stream接口中。

一句话，Stream接口只提供了通用的max()、min()、count()，而且要自己指定Comparator（策略模式）。

但是，如果你能确定元素的类型，比如int、long啥的，那么可以选择对应的mapToInt()、mapToLong()等方法得到具体类型的Stream：

比如得到IntStream后，多了几个方法：

转为具体类型的Stream有以下好处：

不用传递Comparator，你都mapToInt()了，那么元素的类型也就确定了，比较的规则自然也确定了（自然数比较）
额外新增sum()、average()，因为对于数字类型来说，求和、求平均是有意义的

也就是说，如果你要操作的数据刚好是int、long、double，那么不妨转为IntStream、LongStream、DoubleStream，api会得到相应的增强！

总结：

如果你想要做通用的数据处理，直接使用map()等方法即可，此时返回的是Stream，提供的都是通用的操作。但如果要统计的数据类型恰好是int、long、double，那么使用mapToXxx()方法转为具体的Stream类型后，方法更多更强大，处理起来更为方便！

看到这，大家应该知道这道题这么解了，就不贴代码了。特别注意下最后那个summaryStatistics()：五合一。

其实，关于统计的方法，Stream共提供了3大类API，后面会总结。有时选择太多也是一种罪过，难怪有些人会感到混乱。

查找

查找其实分为两大类操作：

查找并返回目标值，以findFirst()为代表
告诉我有没有即可，无需返回目标值，以anyMatch()为代表

public static void main(String[] args) {
    Optional<Person> personMatch = list.stream()
            .filter(person -> "宁波".equals(person.getAddress())) // 经过一些筛选，看看有没有符合条件的元素
            .findFirst();
    personMatch.ifPresent(System.out::println); // 不了解Optional的同学，可以去看后面关于Optional的章节
}

public static void main(String[] args) {
    // 但有时候你并不关心符合条件的是哪个或哪些元素，只想知道有没有，此时anyMatch()更合适，代码会精炼很多
    boolean exists = list.stream().anyMatch(person -> "宁波".equals(person.getAddress()));
}

其他3个方法：findAny()、noneMatch()、allMatch()就不介绍了。

collect()

最牛逼的一个方法，当你想要实现某种操作却一时找不到具体方法时，一般都是在collect()里，因为它玩法实在太多了！

List转List：Collectors.toList()

所谓List转List，一般指的是原List经过filter()、sorted()、map()、limit()等一顿操作后，最终还是以List的形式返回。

public static void main(String[] args) {
    List<String> top2Adult = list.stream()
            .filter(person -> person.getAge() >= 18)          // 过滤得到年龄大于等于18岁的人
            .sorted(Comparator.comparingInt(Person::getAge))  // 按年龄排序
            .map(Person::getName)                             // 得到姓名
            .limit(2)                                         // 取前两个数据
            .collect(Collectors.toList());                    // 得到List<String> names
    System.out.println(top2Adult);
}

问一个问题：Collectors.toList()默认返回的是ArrayList，如何指定返回LinkedList或其他类型呢？答案见下方练习题。

List转Map：Collectors.toMap()

list转map，一般来说关注两个点：

转化后，你要以什么作为key，以什么作为value
出现key冲突时怎么解决（保留旧的值还是覆盖旧的值）

public static void main(String[] args) {
    Map<String, Person> personMap = list.stream().collect(Collectors.toMap(
        Person::getName,    // 以name作为key
        person -> person,   // person->person表示保留整个person作为value
        (pre, next) -> pre  // (pre, next) -> pre)表示key冲突时保留旧值
    ));
    System.out.println(personMap);
}

// 如果你只需要person的部分数据作为value，比如address
public static void main(String[] args) {
    Map<String, String> personMap = list.stream().collect(Collectors.toMap(
        Person::getName, 
        Person::getAddress, 
        (pre, next) -> pre
    ));
    System.out.println(personMap);
}

有时你会见到同事这样写：

public static void main(String[] args) {
    // Function.identity() 本质上等于 person->person
    Map<String, Person> personMap = list.stream().collect(Collectors.toMap(
        Person::getName, 
        Function.identity()
    ));
    System.out.println(personMap);
}

// Function接口定义的方法
static <T> Function<T, T> identity() {
    return t -> t;
}

Function.identity()只是person->person的另类写法，易读性并不好，而且并没有指定key冲突策略：

所以，即使使用Function.identity()，仍需要手动指定key冲突策略：

public static void main(String[] args) {
    Map<String, Person> personMap = list.stream().collect(Collectors.toMap(
        Person::getName, 
        Function.identity(),  // 看起来很酷，其实就是v->v，甚至不如v->v直观
        (pre, next) -> pre
    ));
    System.out.println(personMap);
}

List转Set：Collectors.toSet()

主要目的是利用Set的特性去重。以最常用的HashSet为例，你是否清楚为什么用HashSet存储自定义对象时，要求重写hashCode()和equals()？

因为HashSet本质还是HashMap，只不过HashSet的value是空，只利用了key（HashSet是单列集合，而HashMap是双列集合）。

使用却很简单：

public static void main(String[] args) {
    // String、Integer这些类本身重写了hashCode()和equals()，可以直接toSet()
    Set<String> names = list.stream().map(Person::getName).collect(Collectors.toSet());
    System.out.println(names);

    // 如果你要对自定义的对象去重，比如Person，那么你必须重写hashCode()和equals()
    Set<Person> persons = list.stream().collect(Collectors.toSet());
    System.out.println(persons);
    
    // 一般来说，用到Collectors.toSet()之前，也是filter()等一顿操作，最后希望去重。像上面那样单纯地想得到Set，可以简单点
    Set<Person> anotherPersons = new HashSet<>(list);
    System.out.println(anotherPersons);
}

@Getter
@Setter
// 利用Lombok的注解，如果有条件建议手写。Lombok默认把所有字段加入计算，但实际上你可能只需要计算id和name就能确定唯一性
@EqualsAndHashCode
@AllArgsConstructor
static class Person {
    private String name;
    private Integer age;
    private String address;
    private Double salary;
}

去重

和Collectors.toSet()一样，但凡要去重，最关键的就是“怎么判断两个对象是否相同”，于是必须明确“怎样才算相同”。在Java中通常有两种做法：

重写hashCode()和equals()
指定Comparator（比较器）

Java8以后Stream API专门提供了distinct()方法用来去重，底层就是根据元素hashCode()和equals方法判断是否相同，然后再去重。

public static void main(String[] args) {
    // 如果不重写Person的hashCode()和equals()，去重无效！！！
    List<Person> persons = list.stream().distinct().collect(Collectors.toList());
    System.out.println(persons);
}

你可能感到诧异：不对啊，我平时工作就是这么去重的。其实你平时的写法是这样的：

public static void main(String[] args) {
    // Integer、String这些基础包装类已经重写了hashCode()和equals()
    List<String> personNameList = list.stream().map(Person::getName).distinct().collect(Collectors.toList());
    System.out.println(personNameList);
}

有时我们的判断标准是，只要某些字段相同就去重（比如name），该怎么做呢？（注意，我希望的是按name去重，但最终得到的还是PersonList，而不是PersonNameList，所以上面的方法行不通）

第一种办法，仍然重写hashCode()和equals()，但只选择需要的字段（比如你只根据name作为判断标准）。

public static void main(String[] args) {
    List<Person> persons = list.stream().distinct().collect(Collectors.toList());
    System.out.println(persons);
}


@Getter
@Setter
@AllArgsConstructor
static class Person  {
    private String name;
    private Integer age;
    private String address;
    private Double salary;

    // IDEA自动生成的
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return name.equals(person.name);
    }

    // IDEA自动生成的
    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    // 不用理会，只是方便打印观察
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", salary=" + salary +
                '}';
    }

}

但这个方法有个缺点，如果这个Pojo不止你一个人用，直接重写hashCode()和equals()可能会影响到别人。

另外hashSet、hashMap这种底层是hash结构的容器，在去重时也会依赖hashCode()和equals()。比如你希望根据name去重，而name是String类型，本身是重写了hashCode()和equals()的，那么可以根据name先去重。比如我们可以利用HashMap完成去重（HashSet同理）：

public static void main(String[] args) {
    // 先通过Map去重，只保留key不同的对象。
    Map<String, Person> personMap = list.stream().collect(Collectors.toMap(
        Person::getName,   // 用person.name做key，由于key不能重复，即根据name去重
        p -> p,            // map的value就是person对象本身
        (pre, next) -> pre // key冲突策略：key冲突时保留前者（根据实际需求调整）
    ));
    
    // 然后收集value即可（特别注意，hash去重后得到的person不保证原来的顺序）
    List<Person> peoples = new ArrayList<>(personMap.values());
    System.out.println(peoples);
}

使用linkedHashSet即可保证顺序，使用collectingAndThen就可以将其转变为List集合

可能还有其他方法，但顶多形式看起来不一样，个人认为底层思路都是一样的：hashCode()和equals()。

介绍完hashCode()和equals()这个派系以后，我们再来说说Comparator，尤其是对于TreeSet这样的容器：

public static void main(String[] args) {
    // 先把元素赶到TreeSet中（根据Comparator去重），然后再倒腾回ArrayList
    List<Person> list = list.stream().collect(
            Collectors.collectingAndThen(
                    Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))),
                    ArrayList::new
            )
    );
}

在创建集合时通过Supplier<C> collectionFactory 指定创建出一个集合

在TreeSet的构造方法中可以指定比较器，该比较器决定了TreeSet的排序规则

上面介绍的几种方式，去重后顺序会打乱。关于去重后如何保持元素顺序，网上有很多方法：

https://www.cnblogs.com/better-farther-world2099/articles/11905740.html

要做到去重并保持顺序，光靠Stream似乎有点无能为力，也显得比较啰嗦。还记得之前封装的ConvertUtil吗？不妨往里面再加一个方法：

/**
 * 去重（保持顺序）
 *
 * @param originList           原数据
 * @param distinctKeyExtractor 去重规则
 * @param <T>
 * @param <K>
 * @return
 */
public static <T, K> List<T> removeDuplication(List<T> originList, Function<T, K> distinctKeyExtractor) {
    LinkedHashMap<K, T> resultMap = new LinkedHashMap<>(originList.size());
    for (T item : originList) {
        K distinctKey = distinctKeyExtractor.apply(item);
        if (resultMap.containsKey(distinctKey)) {
            continue;
        }
        resultMap.put(distinctKey, item);
    }
    return new ArrayList<>(resultMap.values());
}

总的来说，去重通常有两类做法：要么通过重写hashCode和equals，要么传入Comparator（Comparable接口也行）。

其实也是借助了LinkedHashMap的特性来完成排序

分组

Stream的分组有两类操作：

字段分组

条件分组

先看字段分组。所谓的groupingBy()，和MySQL的GROUP BY很类似，比如：

public static void main(String[] args) throws JsonProcessingException {
    // 简单版
    Map<String, List<Person>> result = list.stream().collect(Collectors.groupingBy(Person::getAddress));
    System.out.println(new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(result));
}

得到的结果类似于：

{
    "温州": [
        {
            "name": "am",
            "age": 19,
            "address": "温州",
            "salary": 777.7
        }
    ],
    "宁波": [
        {
            "name": "iron",
            "age": 17,
            "address": "宁波",
            "salary": 888.8
        }
    ],
    "杭州": [
        {
            "name": "i",
            "age": 18,
            "address": "杭州",
            "salary": 999.9
        },
        {
            "name": "iron",
            "age": 21,
            "address": "杭州",
            "salary": 888.8
        }
    ]
}

总的来说，groupingBy()的最终结果是Map，key是分组的字段，value是属于该分组的所有元素集合，默认是List。

为什么我说默认是List呢？因为我们还可以自行指定将分组元素收集成到什么容器中，比如Set：

public static void main(String[] args) throws JsonProcessingException {
    // groupingBy()还可以传入第二个参数，指定如何收集元素
    Map<String, Set<Person>> result = list.stream()
							    .collect(Collectors.groupingBy(Person::getAddress, Collectors.toSet()));
    System.out.println(new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(result));
}

如果你期望得到的是各个城市的年龄构成呢？比如：

{
    "温州": [
        19
    ],
    "宁波": [
        17
    ],
    "杭州": [
        18,
        21
    ]
}

做法是，可以把Collectors.toSet()替换成Collectors.mapping(Function mapper,Collector)，然后进行嵌套：

public static void main(String[] args) throws JsonProcessingException {
    // 进阶版版
    Map<String, List<Integer>> result = list.stream().collect(Collectors.groupingBy(
            Person::getAddress,                                        // 以Address分组
            Collectors.mapping(Person::getAge, Collectors.toList()))   // mapping()的做法是先映射再收集
    );
    System.out.println(new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(result));
}

其他过于复杂的api就不再介绍了，太多了反而会乱。实际开发时，如果遇到某个场景，可以自行百度，一般都能解决问题。总之要记住，collect()里面经常可以通过“套娃”操作完成复杂的需求。

有了这么好用的groupingBy()，为啥还需要partitioningBy()呢？因为groupingBy()也是有局限性的，它不能自定义“分组条件”。比如，如果你的分组条件是：

年龄大于18岁 && 来自杭州的分为一组
其他的分为另一组

那么groupingBy()就无能为力了。

此时，支持自定义分组条件的partitioningBy()就派上用场：

public static void main(String[] args) throws JsonProcessingException {
    // 简单版
    Map<Boolean, List<Person>> result = 
						    list.stream().collect(Collectors.partitioningBy(StreamTest::condition));
    System.out.println(new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(result));
}

// 年龄大于18，且来自杭州
private static boolean condition(Person person) {
    return person.getAge() > 18
        && "杭州".equals(person.getAddress());
}

{
    "false": [
        {
            "name": "i",
            "age": 18,
            "address": "杭州",
            "salary": 999.9
        },
        {
            "name": "am",
            "age": 19,
            "address": "温州",
            "salary": 777.7
        },
        {
            "name": "iron",
            "age": 17,
            "address": "宁波",
            "salary": 888.8
        }
    ],
    "true": [
        {
            "name": "iron",
            "age": 21,
            "address": "杭州",
            "salary": 888.8
        }
    ]
}

partitioningBy()也返回Map，但key是true/false，因为条件分组的依据要么true、要么false。partitioningBy()也支持各种嵌套，大家自己尝试即可。

排序

说到排序，大家最先想到的是Stream API中的sorted()，共有两个方法，其中一个支持传入Comparator：

排序的前提是比较，而只要涉及到比较，就必须明确比较的标准是什么。

public static void main(String[] args) {
    List<Person> result = list.stream().sorted().collect(Collectors.toList());
    System.out.println(result);
}

大家猜猜上面代码的运行结果是什么？

答案是：ClassCastException。

在学习Java基础时，我们了解到，如果希望进行对象间的比较：

要么对象实现Comparable接口（对象自身可比较）
要么传入Comparator进行比较（引入中介，帮对象们进行比较）

就好比你和朋友进行100米比赛，要么你们自己计时，要么请个裁判。而上面sorted()既然没有传入Comparator，那么Person要实现Comparable接口：

public static void main(String[] args) {
    List<Person> result = list.stream().sorted().collect(Collectors.toList());
    System.out.println(result);
}


@Getter
@Setter
@EqualsAndHashCode
@AllArgsConstructor
static class Person implements Comparable<Person> {
    private String name;
    private Integer age;
    private String address;
    private Double salary;


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", salary=" + salary +
                '}';
    }
 
    // 定义比较规则
    @Override
    public int compareTo(Person anotherPerson) {
        return anotherPerson.getAge() - this.getAge();
    }
}

sorted()容易采坑而且语义不够明确，个人建议使用sort(Comparator)，显式地传入比较器：

public class ComparatorTest {

    private static List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person("i", 18, 170));
        list.add(new Person("am", 19, 180));
        list.add(new Person("am", 20, 180));
        list.add(new Person("iron", 19,  181));
        list.add(new Person("iron", 19,  179));
        list.add(new Person("man", 17,  160));
        list.add(new Person("man", 16,  160));
    }

    public static void main(String[] args) {
        // 先按身高降序，再按年龄降序
        list.sort(Comparator.comparingInt(Person::getHeight).thenComparingInt(Person::getAge).reversed());
        System.out.println(list);

        // 先按身高升序，再按年龄升序
        list.sort(Comparator.comparingInt(Person::getHeight).thenComparingInt(Person::getAge));
        System.out.println(list);

        // 先按身高降序，再按年龄升序
        list.sort(Comparator.comparingInt(Person::getHeight).reversed().thenComparingInt(Person::getAge));
        System.out.println(list);

        // 先按身高升序，再按年龄降序
        list.sort(Comparator.comparingInt(Person::getHeight).thenComparing(Person::getAge, Comparator.reverseOrder()));
        System.out.println(list);

        /**
         * 大家可以理解为Comparator要实现排序可以有两种方式：
         * 1、comparingInt(keyExtractor)、comparingLong(keyExtractor)... + reversed()表示倒序，默认正序
         * 2、comparing(keyExtractor, Comparator.reverseOrder())，不传Comparator.reverseOrder()表示正序
         * 
         * 第四个需求如果采用reversed()，似乎达不到效果，反正我没查到。
         * 个人建议，单个简单的排序，无论正序倒序，可以使用第一种，简单一些。但如果涉及多个联合排序，建议使用第二种，语义明确不易搞错。
         * 
         * 最后，上面是直接使用Collection的sort()方法，请大家自行改成Stream中的sorted()实现一遍。
         */
    }


    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class Person {
        private String name;
        private Integer age;
        private Integer height;
    }
}

截取

对于List的截取，可能大家都习惯用List.subList()，但它有个隐形的坑：对截取后的List进行元素修改，会影响原List（除非你就希望改变原List）。

究其原因，subList()并非真的从原List截取出元素，而是偏移原List的访问坐标罢了，SubList的get方法：

比如你要截取(5, 6)，那么下次你get(index)，我就直接返回5+index给你，看起来好像真的截取了。

另外，这个方法限制太大，用起来也麻烦，比如对于一个不确定长度的原List，如果你想做以下截取操作：list.subList(0, 5)或者list.subList(2, 5)，当原List长度不满足List.size()>=5时，会抛异常。为了避免误操作，你必须先判断size：

if(list != null && list.size()>=5) {
    return list.subList(2, 5);
}

较为简便和安全的做法是借助Stream（Stream一个很重要的特性是，不修改原数据，而是新产生一个流）：

public static void main(String[] args) {

    List<String> list = Lists.newArrayList("a", "b", "c", "d");

    List<String> limit3 = list.stream().limit(3).collect(Collectors.toList());
    // 超出实际长度也不会报错
    List<String> limit5 = list.stream().limit(5).collect(Collectors.toList());
    List<String> range3_4 = list.stream().skip(2).limit(2).collect(Collectors.toList());
    // 超出实际长度也不会报错
    List<String> range3_5 = list.stream().skip(2).limit(3).collect(Collectors.toList());

    System.out.println(limit3 + " " + limit5 + " " + range3_4 + " " + range3_5);
}

多用Stream

Stream有个很重要的特性，常常被人忽略：Stream操作并不改变原数据。这个特性有什么用呢？

假设有两个List，AList和BList。AList固定10个元素，BList元素长度不固定，0~10个。

要求：

要把AList和BList合并，BList的元素在前，合并后的List不能有重复元素（过滤AList），且不改变两个List原有元素的顺序。

你可以先思考一下怎么处理。

之前介绍过List转Map然后利用Key去重的方法，但转Map后元素顺序可能会打乱，为了保证顺序，你可能会选择双层for：

for (int i = aList.size() - 1; i >= 0; i--) {
    for (Item bItem : bList) {
        // 注意，思考一下aItem.get(i)有没有问题
        if (Objects.equals(bItem.getItemId(), aList.get(i).getItemId())) {
            aList.remove(i);
        }
    }
}

// bList在前
bList.addAll(aList);

当aList.remove(i)以后，第二层for又执行aList.get(i)就有可能造成数组越界异常，比如aList.remove(9)，移除第10个元素，但第二层for在下一轮还是aList.get(9)，此时aList其实只有9个元素。改进的写法可以是这样：

for (int i = aList.size() - 1; i >= 0; i--) {
    // 在第一层for取出aItem，且只取一次
    Item aItem = aList.get(i);
    
    for (Item bItem : bList) {
        if (Objects.equals(bItem.getItemId(), aItem.getItemId())) {
            aList.remove(i);
        }
    }
}

// bList在前
bList.addAll(aList);

但这样不够直观，而且下次再有类似需求，可能还是心惊胆战。此时使用Stream可以编写出更为安全、易读的代码：

Map<String, Item> bItemMap = ConvertUtil.listToMap(bList, Item::getItemId);

// 对aList去重（收集bList中没有的元素）
aList = aList.stream().filter(aItem -> !bItemMap.contains(aItem.getItemId())).collect(Collectors.toList());

// bList在前
bList.addAll(aList);

当然，List其实也提供了取并集、差集的方法，只不过上面的做法会更通用一些，但这不是重点。这里主要是想提醒大家，对于原数组的增删改操作一不小心会带来意想不到的问题，比如数组越界、并发修改异常等，此时用Stream往往是更安全的做法。

总结

filter()、map()如果逻辑过长，最好抽取函数
IntStream、LongStream、DoubleStream在统计方面比Stream方法更丰富，更好用
collect()是最强大的，但一般掌握上面6种情景问题不大
去重的原理是利用hashCode()和equals()来确定两者是否相同，无论是自定义对象还是String、Integer等常用内置对象，皆是如此
排序的原理是，要么自身实现Comparable接口，要么传入Comparator对象，总之要明确比较的规则
平时可能觉得skip()、limit()用不到，但需要截取List或者内存分页时，可以尝试一下
尽量用Stream代替List原生操作，代码健壮性和可读性都会提升一个台阶

flatMap

public class FlatMapTest {
    /**
     * 需求：
     * 1.要求返回所有的key，格式为 list<Long>      提示:keyset
     * 2.要求最终返回所有value，格式为 List<Long>   提示:flatMap()，Function需要啥你就转成啥
     *
     * @param args
     */
    public static void main(String[] args) {
        Map<Long, List<Long>> map = new HashMap<>();
        map.put(1L, new ArrayList<>(Arrays.asList(1L, 2L, 3L)));
        map.put(2L, new ArrayList<>(Arrays.asList(4L, 5L, 6L)));
    }
}

List<Long> keys = map.keySet().stream().toList();  
System.out.println(keys);  
  
List<Long> values = map.keySet().stream().flatMap(key -> map.get(key).stream()).toList();  
System.out.println(values);

//更好的方法
List<Long> valueList = map.values().stream().flatMap(Collection::stream).collect(Collectors.toList());

分组统计：

private static List<Person> list;

static {
    list = new ArrayList<>();
    list.add(new Person("i", 18, "杭州", 999.9));
    list.add(new Person("am", 19, "温州", 777.7));
    list.add(new Person("iron", 21, "杭州", 888.8));
    list.add(new Person("man", 17, "宁波", 888.8));
}

1.要求分组统计出各个城市的年龄总和，返回格式为 Map<String, Integer>。

Map<String, Integer> ageSumByCity = list.stream().collect(Collectors  
        .groupingBy(Person::getAddress,  
                Collectors.mapping(Function.identity(), Collectors.summingInt(Person::getAge))));  
System.out.println(ageSumByCity);

2.要求得到Map<城市, List<用户工资>>

Map<String, List<Double>> salaryListByCity = list.stream()  
        .collect(Collectors.groupingBy(Person::getAddress,  
                Collectors.mapping(Person::getSalary, Collectors.toList())));  
System.out.println(salaryListByCity);

实际开发遇到的问题：处理优惠券信息

public class CouponTest {

    public static void main(String[] args) throws JsonProcessingException {
        List<CouponResponse> coupons = getCoupons();
        
        // TODO 对优惠券统计数量
	    //1. 不使用Stream，直接new HashMap操作

		//2. hashMap + stream
		List<CouponResponse> coupons = getCoupons();  
		coupons.stream()
			.collect(Collectors.toMap(CouponResponse::getId, couponResponse -> {    
			    CouponInfo couponInfo = new CouponInfo();  
			    couponInfo.setId(couponResponse.getId());  
			    couponInfo.setName(couponResponse.getName());  
			    couponInfo.setNum(1);  
			    couponInfo.setCondition(couponResponse.getCondition());  
			    couponInfo.setDenominations(couponResponse.getDenominations());  
			    return couponInfo;  
			},(pre,next) ->{  
			  pre.setNum(pre.getNum() + 1);  
			  return pre;  
			}));

       
    }

    private static List<CouponResponse> getCoupons() {
        return Lists.newArrayList(
                new CouponResponse(1L, "满5减4", 500L, 400L),
                new CouponResponse(1L, "满5减4", 500L, 400L),
                new CouponResponse(2L, "满10减9", 1000L, 900L),
                new CouponResponse(3L, "满60减50", 6000L, 5000L)
        );
    }

    @Data
    @AllArgsConstructor
    static class CouponResponse {
        private Long id;
        private String name;
        private Long condition;
        private Long denominations;
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    static class CouponInfo {
        private Long id;
        private String name;
        private Integer num;
        private Long condition;
        private Long denominations;
    }
}

标签：07,Person,list,List,String,new,public,表达式,Lambda
From： https://www.cnblogs.com/euneirophran/p/18069791

07-Lambda表达式

泛型

自动类型推断机制

泛型擦除

泛型的擦除与补偿

泛型类

泛型方法

泛型接口

泛型的继承和通配符

泛型思考

上：特定化与泛型

形式类型参数、实际类型参数

ArrayList与泛型

下：泛型实现机制

泛型擦除与自动类型转换

泛型与多态

泛型：其实一切都是确定的

泛型真的把对象类型弄成了变量吗

对象类型不确定导致JVM无法创建对象？

一点补充

泛型边界

简单泛型

正向思考

反向思考

泛型的指向和存取

通配符

extends：上边界通配符

super：下边界通配符

?：无界通配符

通配符的使用场景

总结

泛型类

泛型类的方法并不是泛型方法

泛型方法

泛型类和泛型方法的使用场景

Redis分布式锁

泛型数组

泛型的应用

Lambda表达式

引例

出行案例

Lambda表达式的本质

Lambda表达式格式解析

函数式编程思想

如何去理解函数式接口

Lambda和匿名内部类

Lambda表达式的使用

Lambda表达式简化

闭包

Java中的闭包

字节码层面测试

四个基本的函数式接口

接口多态与方法多态

接口多态

方法多态

晚绑定和模板方法设计模式

内部迭代与外部迭代

外部迭代

内部迭代

StreamAPI 设计分析

模拟filter()

模拟map()

方法引用

方法引用的分类

引用静态方法

引用成员方法

引用构造方法

其他方式调用

类名引用成员方法

引用数组构造方法

练习

Lambda表达式与方法引用

引例

从Lambda到方法引用

Lambda表达式VS方法引用

后话

函数式接口

为什么函数式接口重要

函数式接口类型

函数式接口作用