目录
Stream相较于传统的foreach的方式处理stream，到底有啥优势？
前言
现在大部分的在行项目使用的都是Java8，因为它足够稳定，能够满足现有的需求开发，基本没有太多的bug和性能问题，而且，在发布的众多版本中，只有java8、java11、java17是长期支持版本，Oracle每三年选择一个版本提供长期支持和更新，其他版本仅支持六个月。新版本一出，就会放弃老版本的技术支持，这也是很少有人使用9~14版本的主要原因。开发人员在升级Java 8时一般会直接升级到Java 11，一般来说，人们不会使用Java 9或10。就算他们用过，应该也都升级到了Java 11。
即使到了现在，关于Java8新特性的研究还在继续，网上仍然在热烈讨论关于Stream和Optional的相关问题。
jdk9引入了模块化系统，看起来很美，可是，对程序员来说，这是一个破坏性的更新，因为JDK做了模块化，但是很多第三方库没有做模块化。
那么是什么理由让之前的开发者，放弃jdk5、jdk6、jdk7，从而选择jdk8的呢？因为jdk8引入了Lambda表达式和流的Java 8对许多开发人员来说都非常有吸引力。同时，微服务、持续发布实践和更好的自动化测试也让接受新版本语言变得更容易，风险比以前更小。
提示：以下是本篇文章正文内容，下面案例可供参考
一、Lambda 表达式
Lambda 表达式是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包。
在 Java 中，Lambda 表达式的格式是像下面这样
// 无参数，无返回值
() -> log.info("Lambda")
// 有参数，有返回值
(int a, int b) -> { a+b }其等价于
log.info("Lambda");
private int plus(int a, int b){
return a+b;
}这种方式最常见的就是匿名内部类 配合Lamdba表达式可以精简代码，让代码更优雅；比如我们在创建线程的时候其中有的方法就需要匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("快速新建并启动一个线程");
}
}).start();以上代码看上去有种乱的感觉但是使用Lambda表达式精简之后
new Thread(()->{
System.out.println("快速新建并启动一个线程");
}).start();哈哈哈，是不是体验到了Lambda的快乐，极大了增加开发效率 ，瞬间感觉清新脱俗了不少，简洁优雅了不少。但是用好Lambda表达式也不是一件容易的事。
Lambda 表达式简化了匿名内部类的形式，可以达到同样的效果，但是 Lambda 要优雅的多。虽然最终达到的目的是一样的，但其实内部的实现原理却不相同。
匿名内部类在编译之后会创建一个新的匿名内部类出来，而 Lambda 是调用 JVM
invokedynamic指令实现的，并不会产生新类。
二、方法引用
方法引用的出现，使得我们可以将一个方法赋给一个变量或者作为参数传递给另外一个方法。::双冒号作为方法引用的符号，比如下面这两行语句，引用 Integer类的 parseInt方法。
Function<String, Integer> s = Integer::parseInt;
Integer i = s.apply("10"); 或者下面这两行，引用 Integer类的 compare方法。（比较大小的方法）
Comparator<Integer> comparator = Integer::compare;
int result = comparator.compare(100,10); 简单介绍一下compare方法
Student[] students = new Student[3];
students[0] = new Student("张磊", 18, 175);
students[1] = new Student("赵华", 20, 160);
students[2] = new Student("王康", 19, 180);
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return Double.compare(o2.getHeight(), o1.getHeight());
}
});这一段代码就是再进行大小比较，一种匿名内部类的方式，使用这种方式可以定制规则，这段代码就是指定通过升高进行大小排序
使用Lambda精简之后
Student[] students = new Student[3];
students[0] = new Student("张磊", 18, 175);
students[1] = new Student("赵华", 20, 160);
students[2] = new Student("王康", 19, 180);
Arrays.sort(students, ( o1, o2) ->
Double.compare(o2.getHeight(), o1.getHeight())
);再比如，下面这两行代码，同样是引用 Integer类的 compare方法，但是返回类型却不一样，但却都能正常执行，并正确返回。
IntBinaryOperator intBinaryOperator = Integer::compare;
int result = intBinaryOperator.applyAsInt(10,100);什么样的方法可以被引用呢？
这么说吧，任何你有办法访问到的方法都可以被引用。
返回值到底是什么类型？
这就问到点儿上了，上面又是 Function、又是Comparator、又是 IntBinaryOperator的，看上去好像没有规律，其实不然。
返回的类型是 Java 8 专门定义的函数式接口，这类接口用 @FunctionalInterface 注解。
比如 Function这个函数式接口的定义如下：
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}还有很关键的一点，你的引用方法的参数个数、类型，返回值类型要和函数式接口中的方法声明一一对应才行。
比如 Integer.parseInt方法定义如下：
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}首先parseInt方法的参数个数是 1 个，而 Function中的 apply方法参数个数也是 1 个，参数个数对应上了，再来，apply方法的参数类型和返回类型是泛型类型，所以肯定能和 parseInt方法对应上。
这样一来，就可以正确的接收Integer::parseInt的方法引用，并可以调用Funciton的apply方法，这时候，调用到的其实就是对应的 Integer.parseInt方法了。
用这套标准套到 Integer::compare方法上，就不难理解为什么即可以用 Comparator<Integer>接收，又可以用 IntBinaryOperator接收了，而且调用它们各自的方法都能正确的返回结果。
Integer.compare方法定义如下：
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
返回值类型 int，两个参数，并且参数类型都是 int。
然后来看Comparator和IntBinaryOperator它们两个的函数式接口定义和其中对应的方法：
@FunctionalInterface
public interface Comparator<T> {
int compare(T o1, T o2);
}
@FunctionalInterface
public interface IntBinaryOperator {
int applyAsInt(int left, int right);
}对不对，都能正确的匹配上，所以前面示例中用这两个函数式接口都能正常接收。其实不止这两个，只要是在某个函数式接口中声明了这样的方法：两个参数，参数类型是 int或者泛型，并且返回值是 int或者泛型的，都可以完美接收。
JDK 中定义了很多函数式接口，主要在
java.util.function包下，还有java.util.Comparator专门用作定制比较器。另外，前面说的Runnable也是一个函数式接口。
2.Stream API(支持链式编程)
Stream概述
stream是JDK8中处理集合的关键抽象概念，可以对集合进行操作，可以执行复杂的查找、过滤和映射数据等操作。stream API提高一种高效且易于使用的处理数据的方式。
stream流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
特点：
- stream自己不会存储元素
- stream不会改变源对象
- stream操作是延迟执行的。会等到需要结果的时候执行。
操作步骤：
- 创建stream流
- 中间操作。这是一个中间操作链，对数据源进行处理，包含filter、map、limit等
- 终止操作。一个终止操作，才执行中间操作链，并产生结果。
我愿称之Lambda表达式为stream流的灵魂，当然 Stream 也不只是 Lambda 表达式就厉害了，真正厉害的还是它的功能，Stream 是 Java 8 中集合数据处理的利器，很多本来复杂、需要写很多代码的方法，比如过滤、分组等操作，往往使用 Stream 就可以在一行代码搞定，当然也因为 Stream 都是链式操作，一行代码可能会调用好几个方法。
以下是创建stream流的各种方式
//Collection集合获取流
Collection<String> list = new ArrayList<>() ;
Stream<String> stream = list.stream();
//Map集合获取流
Map<String, Integer> maps = new HashMap<>();
//键流
Stream<String> stream1 = maps.keySet().stream();
//值流
Stream<Integer> stream2 = maps.values().stream();
//键值对流
Stream<Map.Entry<String, Integer>> stream3 = maps.entrySet().stream();
//数组获取流
String[] s = {"赵敏", "张无极", "张三丰", "周芷若", "张强"};
Stream<String> stream4 = Arrays.stream(s);//方式一
Stream<String> stream5 = Stream.of(s);//方式二
Collections.addAll(list, "赵敏","张无极", "张三丰", "周芷若", "张强");
Collection接口提供了stream()方法，让我们可以在一个集合方便的使用 Stream API 来进行各种操作。值得注意的是，我们执行的任何操作都不会对源集合造成影响，你可以同时在一个集合上提取出多个 stream 进行操作。
简单欣赏一下stream流
List<String> list = new ArrayList<>();
Collections.addAll(list, "赵敏","张无极", "张三丰", "周芷若", "张强");
list.stream().filter( s -> s.startsWith("张") ).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
这段代码是先过滤符合条件的目标再进行遍历，并且按照条件过滤符合要求的元素， 返回新的stream流。直观感受上，
Stream的实现方式代码更加简洁、一气呵成。很多的同学在代码中也经常使用Stream流，但是对Stream流的认知往往也是仅限于会一些简单的filter、map、collect等操作，但JAVA的Stream可以适用的场景与能力远不止这些。
- 开始管道
主要负责新建一个Stream流，或者基于现有的数组、List、Set、Map等集合类型对象创建出新的Stream流。
| API | 功能说明 |
|---|---|
| stream() | 创建出一个新的stream串行流对象 |
| parallelStream() | 创建出一个可并行执行的stream流对象 |
| Stream.of() | 通过给定的一系列元素创建一个新的Stream串行流对象 |
- 中间管道
负责对Stream进行处理操作，并返回一个新的Stream对象，中间管道操作可以进行叠加。
| API | 功能说明 |
|---|---|
| filter() | 按照条件过滤符合要求的元素， 返回新的stream流 |
| map() | 将已有元素转换为另一个对象类型，一对一逻辑，返回新的stream流 |
| flatMap() | 将已有元素转换为另一个对象类型，一对多逻辑，即原来一个元素对象可能会转换为1个或者多个新类型的元素，返回新的stream流 |
| limit() | 仅保留集合前面指定个数的元素，返回新的stream流 |
| skip() | 跳过集合前面指定个数的元素，返回新的stream流 |
| concat() | 将两个流的数据合并起来为1个新的流，返回新的stream流 |
| distinct() | 对Stream中所有元素进行去重，返回新的stream流 |
| sorted() | 对stream中所有的元素按照指定规则进行排序，返回新的stream流 |
| peek() | 对stream流中的每个元素进行逐个遍历处理，返回处理后的stream流 |
- 终止管道
顾名思义，通过终止管道操作之后，Stream流将会结束，最后可能会执行某些逻辑处理，或者是按照要求返回某些执行后的结果数据。
| API | 功能说明 |
|---|---|
| count() | 返回stream处理后最终的元素个数 |
| max() | 返回stream处理后的元素最大值 |
| min() | 返回stream处理后的元素最小值 |
| findFirst() | 找到第一个符合条件的元素时则终止流处理 |
| findAny() | 找到任何一个符合条件的元素时则退出流处理，这个对于串行流时与findFirst相同，对于并行流时比较高效，任何分片中找到都会终止后续计算逻辑 |
| anyMatch() | 返回一个boolean值，类似于isContains(),用于判断是否有符合条件的元素 |
| allMatch() | 返回一个boolean值，用于判断是否所有元素都符合条件 |
| noneMatch() | 返回一个boolean值， 用于判断是否所有元素都不符合条件 |
| collect() | 将流转换为指定的类型，通过Collectors进行指定 |
| toArray() | 将流转换为数组 |
| iterator() | 将流转换为Iterator对象 |
| foreach() | 无返回值，对元素进行逐个遍历，然后执行给定的处理逻辑 |
Stream方法使用
map与flatMap
map与flatMap都是用于转换已有的元素为其它元素，区别点在于：
- map 必须是一对一的，即每个元素都只能转换为1个新的元素
- flatMap 可以是一对多的，即每个元素都可以转换为1个或者多个新的元素
比如：有一个字符串ID列表，现在需要将其转为User对象列表。可以使用map来实现：
List<String> ids = Arrays.asList("205", "105", "308", "469", "627", "193", "111");
// 使用流操作
List<User> results = ids.stream()
.map(id -> {
User user = new User();
user.setId(id);
return user;
})
.collect(Collectors.toList());
System.out.println(results);
再比如：现有一个句子列表，需要将句子中每个单词都提取出来得到一个所有单词列表。这种情况用map就搞不定了，需要flatMap上场了：
List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
// 使用流操作
List<String> results = sentences.stream()
.flatMap(sentence -> Arrays.stream(sentence.split(" ")))
.collect(Collectors.toList());
System.out.println(results);
这里需要补充一句，flatMap操作的时候其实是先每个元素处理并返回一个新的Stream，然后将多个Stream展开合并为了一个完整的新的Stream
peek和foreach方法
peek和foreach，都可以用于对元素进行遍历然后逐个的进行处理。
但根据前面的介绍，peek属于中间方法，而foreach属于终止方法。这也就意味着peek只能作为管道中途的一个处理步骤，而没法直接执行得到结果，其后面必须还要有其它终止操作的时候才会被执行；而foreach作为无返回值的终止方法，则可以直接执行相关操作。
filter、sorted、distinct、limit
这几个都是常用的Stream的中间操作方法，具体的方法的含义在上面的表格里面有说明。具体使用的时候，可以根据需要选择一个或者多个进行组合使用，或者同时使用多个相同方法的组合：
List<String> ids = Arrays.asList("205","10","308","49","627","193","111", "193");
// 使用流操作
List<Dept> results = ids.stream()
.filter(s -> s.length() > 2)
.distinct()
.map(Integer::valueOf)
.sorted(Comparator.comparingInt(o -> o))
.limit(3)
.map(id -> new Dept(id))
.collect(Collectors.toList());
System.out.println(results);
- 使用filter过滤掉不符合条件的数据
- 通过distinct对存量元素进行去重操作
- 通过map操作将字符串转成整数类型
- 借助sorted指定按照数字大小正序排列
- 使用limit截取排在前3位的元素
- 又一次使用map将id转为Dept对象类型
- 使用collect终止操作将最终处理后的数据收集到list中
简单结果终止方法
按照前面介绍的，终止方法里面像count、max、min、findAny、findFirst、anyMatch、allMatch、nonneMatch等方法，均属于这里说的简单结果终止方法。所谓简单，指的是其结果形式是数字、布尔值或者Optional对象值等。
List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
// 统计stream操作后剩余的元素个数
System.out.println(ids.stream().filter(s -> s.length() > 2).count());
// 判断是否有元素值等于205
System.out.println(ids.stream().filter(s -> s.length() > 2).anyMatch("205"::equals));
// findFirst操作
ids.stream().filter(s -> s.length() > 2)
.findFirst()
.ifPresent(s -> System.out.println("findFirst:" + s));
这里需要补充提醒下，一旦一个Stream被执行了终止操作之后，后续便不可以再读这个流执行其他的操作了，否则会报错。 因为stream已经被执行count()终止方法了，所以对stream再执行anyMatch方法的时候，就会报错stream has already been operated upon or closed
结果收集终止方法
因为Stream主要用于对集合数据的处理场景，所以除了上面几种获取简单结果的终止方法之外，更多的场景是获取一个集合类的结果对象，比如List、Set或者HashMap等。
这里就需要collect方法出场了，它可以支持生成如下类型的结果数据：
- 一个
集合类，比如List、Set或者HashMap等 - StringBuilder对象，支持将多个
字符串进行拼接处理并输出拼接后结果 - 一个可以记录个数或者计算总和的对象（
数据批量运算统计）
生成集合
应该算是collect最常被使用到的一个场景了：
List<Dept> ids = Arrays.asList(new Dept(17), new Dept(22), new Dept(23));
// collect成list
List<Dept> collectList = ids.stream().filter(dept -> dept.getId() > 20)
.collect(Collectors.toList());
System.out.println("collectList:" + collectList);
// collect成Set
Set<Dept> collectSet = ids.stream().filter(dept -> dept.getId() > 20)
.collect(Collectors.toSet());
System.out.println("collectSet:" + collectSet);
// collect成HashMap，key为id，value为Dept对象
Map<Integer, Dept> collectMap = ids.stream().filter(dept -> dept.getId() > 20)
.collect(Collectors.toMap(Dept::getId, dept -> dept));
System.out.println("collectMap:" + collectMap);
生成拼接字符串
将一个List或者数组中的值拼接到一个字符串里并以逗号分隔开，这个场景相信大家都不陌生吧？
如果通过for循环和StringBuilder去循环拼接，还得考虑下最后一个逗号如何处理的问题，很繁琐:
List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
StringBuilder builder = new StringBuilder();
for (String id : ids) {
builder.append(id).append(',');
}
// 去掉末尾多拼接的逗号
builder.deleteCharAt(builder.length() - 1);
System.out.println("拼接后：" + builder.toString());
但是现在有了Stream，使用collect可以轻而易举的实现：
List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
String joinResult = ids.stream().collect(Collectors.joining(","));
System.out.println("拼接后：" + joinResult);
Stream的魅力之处就在于其可以结合到其它的业务逻辑中进行处理，让代码逻辑更加的自然、一气呵成。如果纯粹是个String字符串拼接的诉求，确实没有必要使用Stream来实现
数据批量数学运算
还有一种场景，实际使用的时候可能会比较少，就是使用collect生成数字数据的总和信息，也可以了解下实现方式：
List<Integer> ids = Arrays.asList(10, 20, 30, 40, 50);
// 计算平均值
Double average = ids.stream().collect(Collectors.averagingInt(value -> value));
System.out.println("平均值：" + average);
// 数据统计信息
IntSummaryStatistics summary = ids.stream().collect(Collectors.summarizingInt(value -> value));
System.out.println("数据统计信息： " + summary);
并行Stream
使用并行流，可以有效利用计算机的多CPU硬件，提升逻辑的执行速度。并行流通过将一整个stream划分为多个片段，然后对各个分片流并行执行处理逻辑，最后将各个分片流的执行结果汇总为一个整体流。
约束与限制
并行流类似于多线程在并行处理，所以与多线程场景相关的一些问题同样会存在，比如死锁等问题，所以在并行流终止执行的函数逻辑，必须要保证线程安全。
Stream相较于传统的foreach的方式处理stream，到底有啥优势？
- 代码更简洁、偏声明式的编码风格，更容易体现出代码的逻辑意图
- 逻辑间解耦，一个stream中间处理逻辑，无需关注上游与下游的内容，只需要按约定实现自身逻辑即可
- 并行流场景效率会比迭代器逐个循环更高
- 函数式接口，延迟执行的特性，中间管道操作不管有多少步骤都不会立即执行，只有遇到终止操作的时候才会开始执行，可以避免一些中间不必要的操作消耗
当然了，Stream也不全是优点，在有些方面也有其弊端：
- 代码调测debug不便
- 程序员从历史写法切换到Stream时，需要一定的适应时间
总结
本文主要介绍了jdk8的新特性 Lambda表达式和stream流 主要参考掘金架构悟道和古时的风筝
如何优雅的写代码你学废了吗
扫一扫
247
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
