java面试题：Stream和方法引用

Stream流：

前提：你需要先了解lambda表达式：
lambda表达式
说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。

思想转变：

整体来看，流式思想类似于工厂车间的“生产流水线”。当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤方案，然后再按照方案去执行它。

Stream（流）是一个来自数据源的元素队列

**元素是特定类型的对象，**形成一个队列。Java中的Stream并不会存储元素，而是按需计算。
数据源 流的来源。 可以是集合，数组 等。
和以前的Collection操作不同， Stream操作还有两个基础的特征：
Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent
style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭
代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

**只有一次：**流只能用一次，用完之后会销毁，属于管道流。

流使用步骤：

当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结
果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以
像链条一样排列，变成一个管道。

传统集合的多步遍历代码

几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元
素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。

 List zhangList = new ArrayList<>();
        for (String name : list) {
            if (name.startsWith("张")) {
                zhangList.add(name);
            }
        }
 
        List shortList = new ArrayList<>();
        for (String name : zhangList) {
            if (name.length() == 3) {
                shortList.add(name);
            }
        }
 
        for (String name : shortList) {
            System.out.println(name);
        }

使用流多步遍历代码：

list.stream()
            .filter(s ‐> s.startsWith("张"))
            .filter(s ‐> s.length() == 3)
            .forEach(System.out::println);

获取流

java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）
获取一个流非常简单，有以下几种常用的方式：
所有的 Collection 集合都可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。

根据Collection获取流

list.stream()

根据Map获取流

java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流
需要分key、value或entry等情况：

 Stream keyStream = map.keySet().stream();
 Stream valueStream = map.values().stream();
 Stream> entryStream = map.entrySet().stream();

根据数组获取流

stream.of(ary)

流的常用方法：

延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方
法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
用。本小节中，终结方法包括 count 和 forEach 方法。

逐一处理：forEach

作用：遍历数据

import java.util.stream.Stream;
public class Demo12StreamForEach {
    public static void main(String[] args) {
        Stream stream = Stream.of("张无忌", "张三丰", "周芷若");
        stream.forEach(name‐> System.out.println(name));
    }
}

这里隐藏了一个Consumer接口

java.util.function.Consumer接口是一个消费型接口。
Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。

过滤：filter

作用：可以通过 filter 方法将一个流转换成另一个子集流。

import java.util.stream.Stream;
 
public class Demo07StreamFilter {
    public static void main(String[] args) {
        Stream original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream result = original.filter(s ‐> s.startsWith("张"));
    }
}

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

该方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的 filter 方法
将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。

映射：map

作用：如果需要将流中的元素映射到另一个流中，可以使用 map 方法

import java.util.stream.Stream;
 
public class Demo08StreamMap {
    public static void main(String[] args) {
        Stream original = Stream.of("10", "12", "18");
        Stream result = original.map(str‐>Integer.parseInt(str));
    }
}

这里隐藏了function接口

这可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”。

统计个数：count

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：

import java.util.stream.Stream;
 
public class Demo09StreamCount {
    public static void main(String[] args) {
        Stream original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream result = original.filter(s ‐> s.startsWith("张"));
        System.out.println(result.count()); // 2
    }
}

取用前几个：limit

limit 方法可以对流进行截取，只取用前n个。

import java.util.stream.Stream;
 
public class Demo10StreamLimit {
    public static void main(String[] args) {
        Stream original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream result = original.limit(2);
        System.out.println(result.count()); // 2
    }
}

跳过前几个：skip

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

import java.util.stream.Stream;
 
public class Demo11StreamSkip {
    public static void main(String[] args) {
        Stream original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream result = original.skip(2);
        System.out.println(result.count()); // 1
    }
}

组合：concat

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

import java.util.stream.Stream;
 
public class Demo12StreamConcat {
    public static void main(String[] args) {
        Stream streamA = Stream.of("张无忌");
        Stream streamB = Stream.of("张翠山");
        Stream result = Stream.concat(streamA, streamB);
    }
}

方法引用：

思想转变：

lamdba存在冗余的情况：

定义一个接口

@FunctionalInterface
public interface Printable {
    void print(String str);
}

使用lamdba表达式进行打印数据：

public class Demo01PrintSimple {
    private static void printString(Printable data) {
        data.print("Hello, World!");
    }
 
    public static void main(String[] args) {
        printString(s ‐> System.out.println(s));
    }
}

方法引用进一步来简化代码：

system.out对象已经存在

println方法也已经存在

public class Demo02PrintRef {
    private static void printString(Printable data) {
        data.print("Hello, World!");
    }
 
    public static void main(String[] args) {
        printString(System.out::println);
    }
}

请注意其中的双冒号 :: 写法，这被称为“方法引用”，而双冒号是一种新的语法。

方法引用符

双冒号 :: 为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方
法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

方法引用使用的场景：

在lamdba表达式中，或者匿名内部类中存在已经有的对象和方法，注意是替换lamdba表达式

使用对象名引用成员变量：

使用类名引用静态成员方法：

使用supper引用父类的成员方法：

supper：：父类成员方法

使用this引用本类的成员方法

this::成员方法

类构造器引用

类名::new

数组的构造器引用

int[]::new