【Java开发】Java8：Stream流及操作符详解

目录

1、Stream流介绍

2、Stream流操作类型

2.1.1、中间操作符汇总（filter、distinct、limit、skip、sorted）

2.1.2、中间操作示例代码

2.1.3、map和flatmap

2.1.4、终止操作符汇总（anyMatch、allMatch、noneMatch、findAny、findFirst、forEach、count、reduce、collect）

2.1.5、终止操作示例代码

---

1、Stream流介绍

Stream是Java8 API的成员，它允许以声明性方式处理数据集合 。简单来说，它可以替代冗余的for循环操作。比如过滤、排序和匹配三个操作需要2-3个for循环实现，那么通过Stream流只需要一条语句即可，我认为Stream流最大的优势在于简化代码（函数式编程写出的代码简洁且意图明确）并且多核友好（只需要调用对应方法即可）。

在Java7中，如果要发现type为grocery的所有交易，然后返回以交易值降序排序好的交易ID集合，我们需要这样写：

List<Transaction> groceryTransactions = new Arraylist<>();
for(Transaction t: transactions){
 if(t.getType() == Transaction.GROCERY){
 groceryTransactions.add(t);
 }
}

Collections.sort(groceryTransactions, new Comparator(){
 public int compare(Transaction t1, Transaction t2){
 return t2.getValue().compareTo(t1.getValue());
 }
});

List<Integer> transactionIds = new ArrayList<>();
for(Transaction t: groceryTransactions){
 transactionsIds.add(t.getId());
}

而在 Java 8 使用 Stream，代码更加简洁易读；而且使用并发模式，程序执行速度更快：

List<Integer> transactionsIds = transactions.parallelStream()
.filter(t -> t.getType() == Transaction.GROCERY)
.sorted(comparing(Transaction::getValue).reversed())
.map(Transaction::getId).collect(toList());

stream流可以说是十分的好用，能极大地提高开发时操作集合（Collection）时的生产力。

2、Stream流操作类型

中间操作（Intermediate）：可以有多个，每次返回一个新的流，可进行链式操作，其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用，仅仅调用到这类方法，并没有真正开始流的遍历。

终端操作（Terminal）：只能有一个，每次执行完，这个流也就用光光了，无法执行下一个操作，因此只能放在最后，Terminal操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个side effect。

2.1.1、中间操作符汇总

流方法	作用
filter	返回一个通过设置的条件过滤出元素的流
distinct	返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流。
limit	返回一个不超过给定长度的流。
skip	返回一个放弃了前n个元素的流。
sorted	返回正序排序后的流
map	接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）。
flatMap	使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。

2.1.2、中间操作示例代码

①filter

/**
 * 功能描述:根据条件过滤集合数据
 */
@Test
public void filter(){
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
    System.out.println(filtered); //[abc, bc, efg, abcd, jkl]
}

②distinct

/**
 * 功能描述:去除集合中重复数据
 */
@Test
public void distinct(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> distincted = strings.stream().distinct().collect(Collectors.toList());
    System.out.println(distincted);//[abc, bc, efg, abcd, jkl]
}

③limit

/**
 * 功能描述:指定获取集合前x条数据，重新构造一个新的集合
 */
@Test
public void limit(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> limited = strings.stream().limit(3).collect(Collectors.toList());
    System.out.println(limited);//[abc, abc, bc]
}

④skip

/**
 * 功能描述:排除集合前x条数据，把后面的数据重新构造一个新的集合
 */
@Test
public void skip(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> skiped = strings.stream().skip(3).collect(Collectors.toList());
    System.out.println(skiped);//[efg, abcd, jkl, jkl]
}

⑤sorted

/**
 * 功能描述 : 对集合进行排序
 */
@Test
public void sorted(){
    List<String> strings1 = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    List<Integer> strings3 = Arrays.asList(10, 2, 30, 22, 1,0, -9);
    List<String> sorted1 = strings1.stream().sorted().collect(Collectors.toList());
    List<Integer> sorted3 = strings3.stream().sorted().collect(Collectors.toList());
    System.out.println(sorted1);//[aba, abc, abcd, abd, efg, jkl, jkl]
    System.out.println(sorted3);//[-9, 0, 1, 2, 10, 22, 30]
}

2.1.3、map和flatmap

区别：简单来说，map返回一个值；flatmap返回一个流，多个值。

/**
 * 功能描述:  通过使用map、flatMap把字符串转换为字符输出对比区别
 */
@Test
public void flatMap2Map(){
    List<String> strings1 = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<Integer> mapStream = strings1.stream().map(String::length).collect(Collectors.toList());
    System.out.println("mapStream:"+mapStream);//[3, 3, 2, 3, 4, 3, 3]

    List<List<String>> stringList = new ArrayList<>();
    List<String> strings2 = Arrays.asList("123", "", "23", "", "1111");
    stringList.add(strings1);
    stringList.add(strings2);
    //flatmap对集合中每个元素加工后，做扁平化处理后（拆分层级，放到同一层）然后返回
    List<String> flatMap = stringList.stream().flatMap(strings ->strings.stream().filter(string -> !string.isEmpty())).collect(Collectors.toList());
    System.out.println("flatMap:"+flatMap);//[abc, abc, bc, efg, abcd, jkl, jkl, 123, 23, 1111]
}

2.1.4、终止操作符汇总

流方法	作用
anyMatch	检查是否至少匹配一个元素，返回boolean。
allMatch	检查是否匹配所有元素，返回boolean。
noneMatch	检查是否没有匹配所有元素，返回boolean。
findAny	将返回当前流中的任意元素。
findFirst	返回第一个元素
forEach	遍历流
count	返回流中元素总数。
reduce	可以将流中元素反复结合起来，得到一个值。
collect	收集器，将流转换为其他形式。

2.1.5、终止操作示例代码

①anyMatch

/**
 * 功能描述 : 判断集合中是否至少存在一个元素满足条件
 */
@Test
public void anyMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().anyMatch(s -> s == "abc");
    System.out.println(b);//true
}

②allMatch

/**
 * 功能描述 : 判断集合中是否所有元素都满足条件
 */
@Test
public void allMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().allMatch(s -> s == "abc");
    System.out.println(b);//false
}

③noneMatch

/**
 * 功能描述 : 判断集合中是否所有元素都不满足条件
 */
@Test
public void noneMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().noneMatch(s -> s == "abc");
    System.out.println(b);//false
}

④findAny

/**
 * 功能描述 : 返回当前流中任意元素
 */
@Test
public void findAny(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Optional<String> any = strings.stream().findAny();
    System.out.println(any.get());//随机一个str
}

⑤findFirst

/**
 * 功能描述 : 返回当前流中第一个元素
 */
@Test
public void findFirst(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Optional<String> first = strings.stream().findFirst();
    System.out.println(first.get());//cv
}

⑥forEach

/**
 * 功能描述 : 遍历流
 */
@Test
public void foreach(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    strings.stream().forEach(System.out::println);
}

⑦count

/**
 * 功能描述 : 返回流中元素总数
 */
@Test
public void count(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    long count = strings.stream().count();
    System.out.println(count);
}

⑧reduce

acc和item分别为strem流中的前后元素~

/**
 * 功能描述 : 将流中元素反复结合起来，得到一个值
 */
@Test
public void reduce(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    //reduce方法一
    Optional<String> reduce1 = strings.stream().reduce((acc,item) -> acc+item);
    //reduce方法二
    String reduce2 = strings.stream().reduce("itcast", (acc, item) -> acc+item);

    System.out.println(reduce1.get()); //cvabdabaefgabcdjkljkl
    System.out.println(reduce2); //itcastcvabdabaefgabcdjkljkl
}

⑨collect

/**
 * 功能描述 : 流转换为其他形式
 */
@Test
public void collect(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Set<String> set = strings.stream().collect(Collectors.toSet());
    List<String> list = strings.stream().collect(Collectors.toList());
    //v.concat("_name"):键，v1 -> v1：值
    Map<String, String> map = strings.stream().collect(Collectors.toMap(v ->v.concat("_name"), v1 -> v1, (v1, v2) -> v1));
    System.out.println(set);
    System.out.println(list);
    System.out.println(map);
}

---

参考文献

1.Java中的Stream流详解_DJL_DJL_DJL的博客-CSDN博客_java的stream

2.一文带你入门Java Stream流，太强了