【**前面的话**】Java中的Stream于1.8版本析出,平时项目中也有用到,今天就系统的来实践一下。下面借用重庆力帆队伍中我个人比较喜欢的球员来操作一波,队员的年龄为了便于展示某些api做了调整,请不要太认真哦。

***

# 壹. Stream理解
在java中我们称Stream为『**流**』,我们经常会用流去对集合进行一些流水线的操作。stream就像工厂一样,只需要把集合、命令还有一些参数灌输到流水线中去,就可以加工成得出想要的结果。这样的流水线能大大简洁代码,减少操作。给我个人的感觉类似JavaScript中的链式函数。

# 贰. Stream流程

```java
原集合 —> 流 —> 各种操作(过滤、分组、统计) —> 终端操作
```

Stream流的操作流程一般都是这样的,先将集合转为流,然后经过各种操作,比如过滤、筛选、分组、计算。最后的终端操作,就是转化成我们想要的数据,这个数据的形式一般还是集合,有时也会按照需求输出count计数。下文会一一举例。

# 叁. API实践

首先,定义一个用户对象,包含姓名、年龄、id三个成员变量:
```java
package com.eelve.training.entity;

import lombok.*;

import javax.persistence.*;

/**
* @ClassName User
* @Description TDO
* @Author zhao.zhilue
* @Date 2019/6/28 15:21
* @Version 1.0
**/
@Data
@Entity
@Table(name = "user")
@ToString
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(exclude={"id","name"})
public class User implements Comparable{
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Integer id;

/**
* Link name.
*/
@Column(name = "name", columnDefinition = "varchar(255) not null")
private String name;

@Column(name = "age")
private Integer age;

public User(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(User o) {
return age.compareTo(o.getAge());
}
}
```
然后在数据库中插入测试数据,见下图:
![streamDataSource](https://img2018.cnblogs.com/blog/1035487/201908/1035487-20190810231303243-27571727.png)

## 3.1过滤
### 1)filter 过滤(T-> boolean)
假如我们要实现过滤出40岁以下的队员,我们可以这样来实现:
```java
@Test
public void testUserStreamFilter(){
List userList = userMapper.getALL();
List resultList = userList.stream().filter(user -> user.getAge() 箭头后面跟着的是一个**boolean**值,可以写任何的过滤条件,就相当于sql中where后面的东西,换句话说,能用sql实现的功能这里都可以实现
执行结果为:
```java
User(id=1, name=费尔南多, age=25)
User(id=2, name=费尔南迪尼奥, age=26)
User(id=3, name=卡尔德克, age=27)
User(id=4, name=阿德里安, age=28)
User(id=5, name=隋维杰, age=26)
```
### 2)distinct 去重
其用法和sql中的使用类似,假如我们要实现过去除用重复年龄的队员,我们可以这样来实现:
```java
@Test
public void testUserDistinct(){
List userList = userMapper.getALL();
List resultList = userList.stream().distinct().collect(Collectors.toList());
for (User user : resultList){
System.out.println(user.toString());
}
}
```
执行结果为:
```java
User(id=1, name=费尔南多, age=25)
User(id=2, name=费尔南迪尼奥, age=26)
User(id=3, name=卡尔德克, age=27)
User(id=4, name=阿德里安, age=28)
User(id=6, name=克鲁伊夫, age=43)
```
### 3)sorted排序
如果流中的元素的类实现了 Comparable 接口,即有自己的排序规则,那么可以直接调用 sorted() 方法对元素进行排序,如:
```java
@Override
public int compareTo(User o) {
return age.compareTo(o.getAge());
}
```
```java
@Test
public void testUserStreamSorted(){
List userList = userMapper.getALL();
List resultList = userList.stream().sorted().collect(Collectors.toList());
for (User user : resultList){
System.out.println(user.toString());
}
}
```
反之, 需要调用 sorted((T, T) -> int) 实现 Comparator 接口。
```java
@Test
public void testUserStreamSortedWithComparator(){
List userList = userMapper.getALL();
List resultList = userList.stream().sorted(Comparator.comparingInt(User::getAge)).collect(Collectors.toList());
for (User user : resultList){
System.out.println(user.toString());
}
}
```
执行结果为:
```java
User(id=1, name=费尔南多, age=25)
User(id=2, name=费尔南迪尼奥, age=26)
User(id=5, name=隋维杰, age=26)
User(id=3, name=卡尔德克, age=27)
User(id=4, name=阿德里安, age=28)
User(id=6, name=克鲁伊夫, age=43)
```
### 4)limit() 返回前n个元素
如果想知道队伍中年龄最小的就可以使用下面来实现:
```java
@Test
public void testUserStreamLimit(){
List userList = userMapper.getALL();
List resultList = userList.stream().limit(2).collect(Collectors.toList());
for (User user : resultList){
System.out.println(user.toString());
}
}
```
执行结果为:
```java
User(id=1, name=费尔南多, age=25)
User(id=2, name=费尔南迪尼奥, age=26)
```
### 5)skip
它的用法和limit正好相反,是去除前面几个元素。
假如我们要去除前面两个元素就可以使用下面的方法来实现:
```java
@Test
public void testUserStreamSkip(){
List userList = userMapper.getALL();
List resultList = userList.stream().skip(2).collect(Collectors.toList());
for (User user : resultList){
System.out.println(user.toString());
}
}
```
执行结果为:
```java
User(id=3, name=卡尔德克, age=27)
User(id=4, name=阿德里安, age=28)
User(id=5, name=隋维杰, age=26)
User(id=6, name=克鲁伊夫, age=43)
```
### 6)组合使用
以上的过滤函数物品们可以组合来使用来实现我们具体的需求,示例代码如下:
```java
@Test
public void testUserStreamSortLimit(){
List userList = userMapper.getALL();
List resultList = userList.stream().sorted().limit(5).collect(Collectors.toList());
for (User user : resultList){
System.out.println(user.toString());
}
}
```
这样我们就可以得到先排序后限制的结果:
```java
User(id=1, name=费尔南多, age=25)
User(id=2, name=费尔南迪尼奥, age=26)
User(id=5, name=隋维杰, age=26)
User(id=3, name=卡尔德克, age=27)
User(id=4, name=阿德里安, age=28)
```

## 3.2 映射
### 1)map(T->R)
map是将T类型的数据转为R类型的数据,比如我们想要设置一个新的list,存储用户所有的城市信息。
```java
@Test
public void testUserStreamMap(){
List userList = userMapper.getALL();
List resultList = userList.stream().map(User::getAge).distinct().collect(Collectors.toList());
System.out.println(resultList.toString());
}
```
这样我们可以得到所有年龄的样本,执行结果为:
```java
[25, 26, 27, 28, 43]
```
### 2)flatMap(T -> Stream)

将流中的每一个元素 T 映射为一个流,再把每一个流连接成为一个流。
```java
@Test
public void testStreamMap(){
List habitsList = new ArrayList();
habitsList.add("唱歌,听歌");
habitsList.add("羽毛球,足球,登山");
habitsList = habitsList.stream().map(s -> s.split(",")).flatMap(Arrays::stream).collect(Collectors.toList());
System.out.println(habitsList);
}
```
执行结果为:
```java
[唱歌, 听歌, 羽毛球, 足球, 登山]
```
这里原集合中的数据由逗号分割,使用split进行拆分后,得到的是Stream,字符串数组组成的流,要使用flatMap的**Arrays::stream**,将Stream转为Stream,然后把流相连接,组成了完整的唱歌, 听歌, 羽毛球, 足球, 登山。
## 3.3 查找
### 1)allMatch(T->boolean)
检测是否全部满足参数行为,假如我们要检测是不是所有队员都是U21的球员:
```java
@Test
public void testUserStreamAllMatch(){
List userList = userMapper.getALL();
boolean isNotU21 = userList.stream().allMatch(user -> user.getAge() >= 21);
System.out.println("是否都不是U21球员:" + isNotU21);
}
```
执行结果为:
```java
是否都不是U21球员:true
```
### 2)anyMatch(T->boolean)

检测是否有任意元素满足给定的条件,比如,想知道是否有26岁的球员:
```java
@Test
public void testUserStreamAnyMatch(){
List userList = userMapper.getALL();
boolean isAgeU26 = userList.stream().anyMatch(user -> user.getAge() == 26);
System.out.println("是否有26岁的球员:" + isAgeU26);
}
```
执行结果为:
```java
是否有26岁的球员:true
```
### 3)noneMatch(T -> boolean)
流中是否有元素匹配给定的 T -> boolean 条件。比如我们要检测是否含有U18的队员:
```java
@Test
public void testUserStreamNoneMatch(){
List userList = userMapper.getALL();
boolean isNotU18 = userList.stream().noneMatch(user -> user.getAge() userList = userMapper.getALL();
Optional firstUser = userList.stream().sorted().findFirst();
System.out.println(firstUser.toString());
}
```
执行结果为:
```java
Optional[User(id=1, name=费尔南多, age=25)]
```
### 5)findAny():找到任意一个元素
```java
@Test
public void testUserFindAny(){
List userList = userMapper.getALL();
Optional anytUser = userList.parallelStream().sorted().findAny();
System.out.println(anytUser.toString());
}
```
执行结果为:
```java
Optional[User(id=2, name=费尔南迪尼奥, age=26)]
```
## 3.4 归纳计算
### 1)求队员的总人数
```java
@Test
public void testUserCount(){
List userList = userMapper.getALL();
long totalAge = userList.stream().collect(Collectors.counting());
System.out.println("队员人数为:" + totalAge);
}
```
执行结果为:
```java
队员人数为:6
```
### 2)得到某一属性的最大最小值
```java
@Test
public void testUserMaxAndMin(){
List userList = userMapper.getALL();
Optional userMaxAge = userList.stream().collect(Collectors.maxBy(Comparator.comparing(User::getAge)));
System.out.println("年龄最大的队员为:" + userMaxAge.toString());

Optional userMinAge = userList.stream().collect(Collectors.minBy(Comparator.comparing(User::getAge)));
System.out.println("年龄最小的队员为:" + userMinAge.toString());
}
```
执行结果为:
```java
年龄最大的队员为:Optional[User(id=6, name=克鲁伊夫, age=43)]
年龄最小的队员为:Optional[User(id=1, name=费尔南多, age=25)]
```
### 3)求年龄总和是多少
```java
@Test
public void testUserSummingInt(){
List userList = userMapper.getALL();
int totalAge = userList.stream().collect(Collectors.summingInt(User::getAge));
System.out.println("年龄总和为:" + totalAge);
}
```
执行结果为:
```java
年龄总和为:175
```
我们经常会用BigDecimal来记录金钱,假设想得到BigDecimal的总和:
// 获得列表对象金额, 使用reduce聚合函数,实现累加器
BigDecimal sum = myList.stream() .map(User::getMoney)
.reduce(BigDecimal.ZERO,BigDecimal::add);
### 4)求年龄平均值
```java
@Test
public void testUserAveragingInt(){
List userList = userMapper.getALL();
Double totalAge = userList.stream().collect(Collectors.averagingInt(User::getAge));
System.out.println("平均年龄为:" + totalAge);
}
```
执行结果为:
```java
平均年龄为:29.166666666666668
```
### 5)一次性得到元素的个数、总和、最大值、最小值
```java
@Test
public void testUserSummarizingInt(){
List userList = userMapper.getALL();
IntSummaryStatistics statistics = userList.stream().collect(Collectors.summarizingInt(User::getAge));
System.out.println("年龄的统计结果为:" + statistics );
}
```
执行结果为:
```java
年龄的统计结果为:IntSummaryStatistics{count=6, sum=175, min=25, average=29.166667, max=43}
```
### 6)字符串拼接
要将队员的姓名连成一个字符串并用逗号分割。
```java
@Test
public void testUserJoining(){
List userList = userMapper.getALL();
String name = userList.stream().map(User::getName).collect(Collectors.joining(","));
System.out.println("所有的队员名字:" + name );
}
```
执行结果为:
```java
所有的队员名字:费尔南多,费尔南迪尼奥,卡尔德克,阿德里安,隋维杰,克鲁伊夫
```
## 3.5 分组
在数据库操作中,我们经常通过GROUP BY关键字对查询到的数据进行分组,java8的流式处理也提供了分组的功能。使用Collectors.groupingBy来进行分组。
### 1)可以根据队员的年龄进行分组
```java
@Test
public void testUserGroupingBy(){
List userList = userMapper.getALL();
Map> ageMap = userList.stream().collect(Collectors.groupingBy(User::getAge));
for (Map.Entry> entry :ageMap.entrySet()){
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
}
```
执行结果为:
```java
key= 25 and value= [User(id=1, name=费尔南多, age=25)]
key= 26 and value= [User(id=2, name=费尔南迪尼奥, age=26), User(id=5, name=隋维杰, age=26)]
key= 43 and value= [User(id=6, name=克鲁伊夫, age=43)]
key= 27 and value= [User(id=3, name=卡尔德克, age=27)]
key= 28 and value= [User(id=4, name=阿德里安, age=28)]
```
结果是一个map,key为不重复的年龄,value为属于该年龄的队员列表。已经实现了分组。另外我们还可以继续分组得到两次分组的结果。

### 2)如果仅仅想统计各年龄的队员个数是多少,并不需要对应的list
按年龄分组并统计人数:
```java
@Test
public void testUserGroupingByCount(){
List userList = userMapper.getALL();
Map ageMap = userList.stream().collect(Collectors.groupingBy(User::getAge,Collectors.counting()));
for (Map.Entry entry :ageMap.entrySet()){
System.out.println("队员中" + entry.getKey() + "岁的队员人数为:" + entry.getValue());
}
}
```
执行结果为:
```java
队员中25岁的队员人数为:1
队员中26岁的队员人数为:2
队员中43岁的队员人数为:1
队员中27岁的队员人数为:1
队员中28岁的队员人数为:1
```
### 3)partitioningBy 分区
分区与分组的区别在于,分区是按照 true 和 false 来分的,因此partitioningBy 接受的参数的 lambda 也是 T -> boolean
```java
@Test
public void testUserPartitioningBy (){
List userList = userMapper.getALL();
Map> partitioningByMap = userList.stream().collect(partitioningBy(user -> user.getAge() >= 30));
for (Map.Entry> entry :partitioningByMap.entrySet()){
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
}
```
执行结果为:
```java
key= false and value= [User(id=1, name=费尔南多, age=25), User(id=2, name=费尔南迪尼奥, age=26), User(id=3, name=卡尔德克, age=27), User(id=4, name=阿德里安, age=28), User(id=5, name=隋维杰, age=26)]
key= true and value= [User(id=6, name=克鲁伊夫, age=43)]
```

***

【**写在后面的话**】留下stream的类实现的方法和依赖图,前面的实践也只是挑选了几个比较常用的Api。

![stream](https://img2018.cnblogs.com/blog/1035487/201908/1035487-20190810231316712-707371379.png)

Java 8 Stream实践的更多相关文章

  1. Java 8 Stream API的使用示例

    前言 Java Stream API借助于Lambda表达式,为Collection操作提供了一个新的选择.如果使用得当,可以极大地提高编程效率和代码可读性. 本文将介绍Stream API包含的方法 ...

  2. Java 8 Stream API详解--转

    原文地址:http://blog.csdn.net/chszs/article/details/47038607 Java 8 Stream API详解 一.Stream API介绍 Java8引入了 ...

  3. Java 理论与实践: 处理 InterruptedException

    捕捉到它,然后怎么处理它? 很多 Java™ 语言方法,例如 Thread.sleep() 和 Object.wait(),都可以抛出InterruptedException.您不能忽略这个异常,因为 ...

  4. java之stream(jdk8)

    一.stream介绍 参考: Java 8 中的 Streams API 详解   Package java.util.stream   Java8初体验(二)Stream语法详解   二.例子 im ...

  5. paip.myeclipse7 java webservice 最佳实践o228

    paip.myeclipse7  java webservice 最佳实践o228 java的ws实现方案:jax-ws>>xfire ws的测试工具  webservice测试调用工具W ...

  6. Java 理论与实践: 非阻塞算法简介——看吧,没有锁定!(转载)

    简介: Java™ 5.0 第一次让使用 Java 语言开发非阻塞算法成为可能,java.util.concurrent 包充分地利用了这个功能.非阻塞算法属于并发算法,它们可以安全地派生它们的线程, ...

  7. Java 理论与实践: 流行的原子——新原子类是 java.util.concurrent 的隐藏精华(转载)

    简介: 在 JDK 5.0 之前,如果不使用本机代码,就不能用 Java 语言编写无等待.无锁定的算法.在 java.util.concurrent 中添加原子变量类之后,这种情况发生了变化.请跟随并 ...

  8. Java 理论和实践: 了解泛型

    转载自 : http://www.ibm.com/developerworks/cn/java/j-jtp01255.html 表面上看起来,无论语法还是应用的环境(比如容器类),泛型类型(或者泛型) ...

  9. Java 8 Stream API Example Tutorial

    Stream API Overview Before we look into Java 8 Stream API Examples, let’s see why it was required. S ...

随机推荐

  1. 并发编程-concurrent指南-阻塞队列-同步队列SynchronousQueue

    SynchronousQueue:同步Queue,属于线程安全的BlockingQueue的一种,此队列设计的理念类似于"单工模式",对于每个put/offer操作,必须等待一个t ...

  2. 开源SQL审核平台——Archery 安装、部署心得

    目录 0.软件版本及项目地址 1.安装python venv环境 1.1.安装 python36 1.2.创建 Python venv 环境(Python>=3.6.5,建议使用虚拟环境 ) 1 ...

  3. POJ 3155:Hard Life(最大密度子图)

    题目链接 题意 给出n个人,和m对有冲突的人.要裁掉一些人,使得冲突率最高,冲突率为存在的冲突数/人数. 思路 题意可以转化为,求出一些边,使得|E|/|V|最大,这种分数规划叫做最大密度子图. 学习 ...

  4. 致远A8任意文件写入漏洞_getshell_exp

    近期爆出致远 OA 系统的一些版本存在任意文件写入漏洞,远程攻击者在无需登录的情况下可通过向 URL /seeyon/htmlofficeservlet POST 精心构造的数据即可向目标服务器写入任 ...

  5. Spring的Ioc模拟实现

      关于IOC:我们讲个故事吧! 有一个厨师,他在做一道菜的时候需要某种调味料(bean),可是他正好没有那瓶调味料(bean),这个时候他就必须去制作一瓶调味料(bean)出来.(这就像我们平时需要 ...

  6. MYSQL手工注入(详细步骤)—— 待补充

    0x00 SQL注入的分类: (1)基于从服务器接收到的响应         ▲基于错误的 SQL 注入         ▲联合查询的类型         ▲堆查询注射         ▲SQL 盲注 ...

  7. 和朱晔一起复习Java并发(二):队列

    和朱晔一起复习Java并发(二):队列 老样子,我们还是从一些例子开始慢慢熟悉各种并发队列.以看小说看故事的心态来学习不会显得那么枯燥而且更容易记忆深刻. 阻塞队列的等待? 阻塞队列最适合做的事情就是 ...

  8. Apache struts2 namespace远程命令执行_CVE-2018-11776(S2-057)漏洞复现

    Apache struts2 namespace远程命令执行_CVE-2018-11776(S2-057)漏洞复现 一.漏洞描述 S2-057漏洞产生于网站配置xml的时候,有一个namespace的 ...

  9. ThreadGroup详细讲解

    import java.util.concurrent.TimeUnit; public class Test { public static void main(String[] args){ // ...

  10. 关于下载安装Photoshop CS6遇到的一些问题

    关于安装Photoshop CS6顺带安装AdobeBridge CS6和Aobe Extension Manager CS6的问题 Bridge是PS的一款插件,它能兼容大多数AODBE公司的软件, ...