5分钟让你快速掌握java8 stream常用开发技巧

前言

如果有些朋友以前没有使用过java8 stream这种链式编程方式做开发，想学习一下。

如果有些朋友只学习了一部分用法，想学习更多。

如果有些朋友想看看有没有好的示例适用于实际工作当中。

那么恭喜你，这篇文章非常适合你。

首先，我们一起看看stream的继承关系：

stream、intstream、longstream、doublestream的父接口都是basestream。basestream的四个子接口方法都差不多，只是intstream、longstream、doublestream直接存储基本类型，可以避免自动装/拆箱，效率会更高一些。但是，我们实际上使用stream更多一些。

我们再看看stream的工作流程图：

为什么要学stream的链式编程方式

业务需求1：指定一个字符串数组，找出里面相同的元素，并且统计重复的次数。

我们以前大概是这样做的：

public class counttest {

 @test
 public void testcount1() {
 list<string> list = lists.newarraylist("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");

 map<string, long> countmap = new hashmap<>();
 for (string data : list) {
  long along = countmap.get(data);
  if (objects.isnull(along)) {
  countmap.put(data, 1l);
  } else {
  countmap.put(data, ++along);
  }
 }

 countmap.foreach((key, value) -> system.out.println("key:" + key + " value:" + value));
 }
}

执行结果：

key:a value:3
key:ab value:2
key:b value:1
key:bd value:1
key:abc value:2
key:abcd value:1

我们再看看如果用java8的stream可以怎么做：

public class counttest {

 @test
 public void testcount2() {
 list<string> list = lists.newarraylist("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
 map<string, long> countmap =  list.stream().collect(collectors.groupingby(function.identity(), collectors.counting()));
 countmap.foreach((key, value) ->  system.out.println("key:" + key + " value:" + value));
 }
}

执行结果：

key:a value:3
key:ab value:2
key:b value:1
key:bd value:1
key:abc value:2
key:abcd value:1

我们可以看到testcount1和testcount2执行结果相同，仅仅一行代码：

map<string, long> countmap = list.stream().collect(collectors.groupingby(function.identity(), collectors.counting()));

就可以实现上面testcount1中多行代码的逻辑。

业务需求2：从一个指定的字符串数组中，查找指定的字符串是否存在

我们以前大概是这样做的：

public class findtest {

 @test
 public void testfind1() {
 string findstr = "bd";
 list<string> list = lists.newarraylist("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
 boolean match = false;
 for (string data : list) {
  if (data.equals(findstr)) {
  match = true;
  break;
  }
 }
 //结果：match:true
 system.out.println("match:" + match);
 }
}

我们再看看如果用java8的stream可以怎么做：

public class matchtest {

 @test
 public void testfind2() {
 string findstr = "bd";
 list<string> list = lists.newarraylist("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
 boolean match = list.stream().anymatch(x -> x.equals(findstr));
 //结果：match:true
 system.out.println("match:" + match);
 }
}

我们可以看到调用testfind1和testfind2方法执行结果也是一样的。但是，用java8 stream的语法，又只用一行代码就完成功能了，真棒。

java8 stream超详细用法指南

stream的操作符大体上分为两种：中间操作符和终止操作符

中间操作：

1.filter(t-> boolean)

过滤数据，保留 boolean 为 true 的元素，返回一个集合

public class filtertest {
 @test
 public void testfilter() {
 list<integer> list = lists.newarraylist(20, 23, 25, 28, 30, 33, 37, 40);
 //从指定数据集合中过滤出大于等于30的数据集合
 list<integer> collect = list.stream().filter(x -> x >= 30).collect(collectors.tolist());
 //结果：[33, 37, 40]
 system.out.println(collect);
 }
}

collect(collectors.tolist())可以把流转换为 list 类型，collect实际上是一个终止操作。

2.map(t -> r)

转换操作符，可以做数据转换，比如：把字符串转换成int、long、double，或者把一个实体转换成另外一个实体。包含：map，maptoint、maptolong、maptodouble

public class maptest {


 @test
 public void testmap() {
 list<string> list = lists.newarraylist("1", "2", "3", "4", "5", "6");
 list<long> collect1 = list.stream().map(x -> long.parselong(x)).collect(collectors.tolist());
 //结果：[1, 2, 3, 4, 5, 6]
 system.out.println(collect1);

 //结果：111111
 list.stream().maptoint(x -> x.length()).foreach(system.out::print);
 system.out.println("");

 //结果：111111
 list.stream().maptolong(x -> x.length()).foreach(system.out::print);
 system.out.println("");

 //结果：1.01.01.01.01.01.0
 list.stream().maptodouble(x -> x.length()).foreach(system.out::print);
 }
}

3.flatmap(t -> stream)

将流中的每一个元素 t 映射为一个流，再把每一个流连接成为一个流

public class flatmaptest {

 @test
 public void testflatmap() {
 list<list<string>> list = new arraylist<list<string>>(){{
  add(lists.newarraylist("a","b","c"));
  add(lists.newarraylist("d","e","f"));
  add(lists.newarraylist("j","k","y"));
 }};
 //结果：[[a, b, c], [d, e, f], [j, k, y]]
 system.out.println(list);
 list<string> collect = list.stream().flatmap(list::stream).collect(collectors.tolist());
 //结果：[a, b, c, d, e, f, j, k, y]
 system.out.println(collect);
 }
}

我们可以看到flatmap可以轻松把字符串的二维数据变成一位数组。

4.distinct

去重，类似于msql中的distinct的作用，底层使用了equals方法做比较。

public class distincttest {

 @test
 public void testdistinct() {
 list<string> list = lists.newarraylist("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
 list<string> collect = list.stream().distinct().collect(collectors.tolist());
 //结果：[a, b, ab, abc, abcd, bd]
 system.out.println(collect);
 }
}

其实，去重还有另外一种办法，可以用collectors.toset()，后面会讲到。

5.sorted

对元素进行排序，前提是实现comparable接口，当然也可以自定义比较器。

public class sorttest {

 @test
 public void testsort() {
 list<integer> list = lists.newarraylist(5, 3, 7, 1, 4, 6);
 list<integer> collect = list.stream().sorted((a, b) -> a.compareto(b)).collect(collectors.tolist());
 //结果：[1, 3, 4, 5, 6, 7]
 system.out.println(collect);
 }
}

6.limit

限流操作，有点类似于mysql中的limit功能，比如：有10个元素，只取前面3个元素

public class limittest {

 @test
 public void testlimit() {
 list<string> list = lists.newarraylist("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
 list<string> collect = list.stream().limit(3).collect(collectors.tolist());
 //结果：[a, b, ab]
 system.out.println(collect);
 }
}

7.skip

跳过操作，比如：有个10个元素，从第5个元素开始去后面的元素

public class skiptest {

 @test
 public void testskip() {
 list<string> list = lists.newarraylist("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
 list<string> collect = list.stream().skip(5).collect(collectors.tolist());
 //结果：[ab, a, abcd, bd, abc]
 system.out.println(collect);
 }
}

8.peek

挑出操作，

public class peektest {
 @test
 public void testpeek() {
 list<string> list = lists.newarraylist("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
 //结果：abababcaabaabcdbdabc
 list.stream().peek(x -> x.touppercase()).foreach(system.out::print);
 }
}

眼尖的朋友会发现，进行x.touppercase()转换为大写功能，但是实际上没有生效。把peek改成map方法试试：

public class peektest {
 @test
 public void testpeek() {
 list<string> list = lists.newarraylist("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
 //结果：abababcaabaabcdbdabc
 list.stream().map(x -> x.touppercase()).foreach(system.out::print);
 }
}

我们可以看到，用map操作转换成大写功能生效了，但是用peek操作却没有生效。peek只是对stream中的元素进行某些操作，但是操作之后的数据并不返回到stream中，所以stream中的元素还是原来的元素。

终止操作：

1.foreach

遍历操作，包含：foreach 和 foreachordered

foreach：支持并行处理

foreachordered：是按顺序处理的，遍历速度较慢

public class foreachtest {

 @test
 public void testforeach() {
 list<string> list = lists.newarraylist("a", "b", "ab");
 //结果：a b ab
 list.stream().foreach(x-> system.out.print(x+' '));
 system.out.println("");

 //可以简化
 //结果：a b ab
 list.foreach(x-> system.out.print(x+' '));
 system.out.println("");

 //结果：a b ab
 list.stream().foreachordered(x-> system.out.print(x+' '));
 }
}

2.collect

收集操作，将所有的元素收集起来，collectors 提供了非常多收集器。包含：tomap、toset、tolist、joining，groupingby，maxby，minby等操作。

tomap：将数据流转换为map，里面包含的元素是用key/value的形式的

toset：将数据流转换为set，里面包含的元素不可重复

tolist：将数据流转出为list，里面包含的元素是有序的

joining：拼接字符串

groupingby：分组，可以将list转换map

couting：统计元素数量

maxby：获取最大元素

minby：获取最小元素

summarizingint: 汇总int类型的元素，返回intsummarystatistics，再调用具体的方法对元素进行统计：getcount（统计数量），getsum（求和），getmin（获取最小值），getmax（获取最大值），getaverage（获取平均值）

summarizinglong：汇总long类型的元素，用法同summarizingint

summarizingdouble：汇总double类型的元素，用法同summarizingint

averagingint：获取int类型的元素的平均值，返回一个double类型的数据

averaginglong：获取long类型的元素的平均值，用法同averagingint

averagingdouble：获取double类型的元素的平均值，用法同averagingint

mapping：获取映射，可以将原始元素的一部分内容作为一个新元素返回

public class collecttest {

 @data
 @allargsconstructor
 class user {
  private string name;
  private integer age;
 }


 @test
 public void testcollect() {
  list<string> list0 = lists.newarraylist("a", "b", "ab");
  map<string, string> collect0 = list0.stream().collect(collectors.tomap(string::new, function.identity()));
  //结果：{ab=ab, a=a, b=b}
  system.out.println(collect0);

  list<string> list = lists.newarraylist("a", "b", "ab", "a", "b", "ab");
  list<string> collect1 = list.stream().collect(collectors.tolist());
  //结果：[a, b, ab, a, b, ab]
  system.out.println(collect1);

  //结果：[a, ab, b]
  set<string> collect2 = list.stream().collect(collectors.toset());
  system.out.println(collect2);

  string collect3 = list.stream().collect(collectors.joining(","));
  //结果：a,b,ab,a,b,ab
  system.out.println(collect3);

  map<string, list<string>> collect4 = list.stream().collect(collectors.groupingby(function.identity()));
  //结果：{ab=[ab, ab], a=[a, a], b=[b, b]}
  system.out.println(collect4);

  long collect = list.stream().collect(collectors.counting());
  //结果：6
  system.out.println(collect);

  string collect5 = list.stream().collect(collectors.maxby((a, b) -> a.compareto(b))).orelse(null);
  //结果：b
  system.out.println(collect5);

  string collect6 = list.stream().collect(collectors.minby((a, b) -> a.compareto(b))).orelse(null);
  //结果：a
  system.out.println(collect6);

  list<string> list2 = lists.newarraylist("2", "3", "5");
  intsummarystatistics summarystatistics = list2.stream().collect(collectors.summarizingint(x -> integer.parseint(x)));
  long sum = summarystatistics.getsum();
  //结果：10
  system.out.println(sum);

  double collect7 = list2.stream().collect(collectors.averagingint(x -> integer.parseint(x)));
  //结果：3.3333333333333335
  system.out.println(collect7);

  list<user> userlist = new arraylist<user>() {{
   add(new user("jack",23));
   add(new user("james",30));
   add(new user("curry",28));
  }};
  list<string> collect8 = userlist.stream().collect(collectors.mapping(user::getname, collectors.tolist()));
  //[jack, james, curry]
  system.out.println(collect8);
 }
}

3.find

查找操作，包含：findfirst、findany

findfirst：找到第一个，返回的类型为optional

findany：使用 stream() 时找到的是第一个元素，使用 parallelstream() 并行时找到的是其中一个元素，返回的类型为optional

public class findoptest {

 @test
 public void testfindop() {
  list<string> list = lists.newarraylist("a", "b", "ab", "abc", "bc", "ab");
  //查找第一匹配的元素
  string data1 = list.stream().findfirst().orelse(null);
  //结果: a
  system.out.println(data1);

  string data2 = list.stream().findany().orelse(null);
  //结果: a
  system.out.println(data2);
 }
}

4.match

匹配操作，包含：allmatch、anymatch、nonematch

allmatch：所有元素都满足条件，返回boolean类型

anymatch：任意一个元素满足条件，返回boolean类型

nonematch：所有元素都不满足条件，返回boolean类型

public class matchtest {

 @test
 public void testmatch() {
  list<integer> list = lists.newarraylist(2, 3, 5, 7);
  boolean allmatch = list.stream().allmatch(x -> x > 1);
  //结果：true
  system.out.println(allmatch);

  boolean allmatch2 = list.stream().allmatch(x -> x > 2);
  //结果：false
  system.out.println(allmatch2);

  boolean anymatch = list.stream().anymatch(x -> x > 2);
  //结果：true
  system.out.println(anymatch);

  boolean nonematch1 = list.stream().nonematch(x -> x > 5);
  //结果：false
  system.out.println(nonematch1);

  boolean nonematch2 = list.stream().nonematch(x -> x > 7);
  //结果：true
  system.out.println(nonematch2);
 }
}

5.count

统计操作，效果跟调用集合的size()方法类似

public class countoptest {

 @test
 public void testcountop() {
  list<string> list = lists.newarraylist("a", "b", "ab");
  long count = list.stream().count();
  //结果：3
  system.out.println(count);
 }
}

6.min、max

min：获取最小值，返回optional类型的数据

max：获取最大值，返回optional类型的数据

public class maxmintest {

 @test
 public void testmaxmin() {
  list<integer> list = lists.newarraylist(2, 3, 5, 7);
  optional<integer> max = list.stream().max((a, b) -> a.compareto(b));
  //结果：7
  system.out.println(max.get());

  optional<integer> min = list.stream().min((a, b) -> a.compareto(b));
  //结果：2
  system.out.println(min.get());
 }
}

7.reduce

规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce。

reduce 操作可以实现从stream中生成一个值，其生成的值不是随意的，而是根据指定的计算模型。

public class reducetest {

 @test
 public void testreduce() {
  list<integer> list = lists.newarraylist(2, 3, 5, 7);
  integer sum1 = list.stream().reduce(0, integer::sum);
  //结果：17
  system.out.println(sum1);

  optional<integer> reduce = list.stream().reduce((a, b) -> a + b);
  //结果：17
  system.out.println(reduce.get());

  integer max = list.stream().reduce(0, integer::max);
  //结果：7
  system.out.println(max);

  integer min = list.stream().reduce(0, integer::min);
  //结果：0
  system.out.println(min);


  optional<integer> reduce1 = list.stream().reduce((a, b) -> a > b ? b : a);
  //2
  system.out.println(reduce1.get());
 }
}

8.toarray

数组操作，将数据流的元素转换成数组。

public class arraytest {

 @test
 public void testarray() {
  list<string> list = lists.newarraylist("a", "b", "ab");
  string[] strings = list.stream().toarray(string[]::new);
  //结果：a b ab
  for (int i = 0; i < strings.length; i++) {
   system.out.print(strings[i]+" ");
  }
 }
}

stream和parallelstream的区别

stream：是单管道，称其为流，其主要用于集合的逻辑处理。

parallelstream：是多管道，提供了流的并行处理，它是stream的另一重要特性，其底层使用fork/join框架实现

public class streamtest {

 @test
 public void teststream() {
  list<integer> list = lists.newarraylist(1,2, 3,4, 5,6, 7);
  //结果：1234567
  list.stream().foreach(system.out::print);
 }
}

public class parallelstreamtest {
 @test
 public void testparallelstream() {
  list<integer> list = lists.newarraylist(1,2, 3,4, 5,6, 7);
  //结果：5726134
  list.parallelstream().foreach(system.out::print);
 }
}

我们可以看到直接使用parallelstream的foreach遍历数据，是没有顺序的。

如果要让parallelstream遍历时有顺序怎么办呢？

public class parallelstreamtest {

 @test
 public void testparallelstream() {
  list<integer> list = lists.newarraylist(1,2, 3,4, 5,6, 7);
  //结果：1234567
  list.parallelstream().foreachordered(system.out::print);
 }
}

parallelstream的工作原理：

实际工作中的案例

1.从两个集合中找相同的元素。一般用于批量数据导入的场景，先查询出数据，再批量新增或修改。

public class worktest {

 @test
 public void testwork1() {
  list<string> list1 = lists.newarraylist("a", "b", "ab");
  list<string> list2 = lists.newarraylist("a", "c", "ab");
  list<string> collect = list1.stream()
    .filter(x -> list2.stream().anymatch(e -> e.equals(x)))
    .collect(collectors.tolist());
  //结果：[a, ab]
  system.out.println(collect);

 }
}

2.有两个集合a和b，过滤出集合a中有，但是集合b中没有的元素。这种情况可以使用在假如指定一个id集合，根据id集合从数据库中查询出数据集合，再根据id集合过滤出数据集合中不存在的id，这些id就是需要新增的。

@test
public void testwork2() {
 list<string> list1 = lists.newarraylist("a", "b", "ab");
 list<string> list2 = lists.newarraylist("a", "c", "ab");
 list<string> collect = list1.stream()
  .filter(x -> list2.stream().nonematch(e -> e.equals(x)))
  .collect(collectors.tolist());
 //结果：[b]
 system.out.println(collect);
}

3.根据条件过滤数据，并且去重做数据转换

 @allargsconstructor
 @data
 class user {
  private string name;
  private integer age;
 }

 @test
 public void testwork3() {
  list<user> userlist = new arraylist<user>() {{
   add(new user("jack",23));
   add(new user("james",30));
   add(new user("curry",28));
   add(new user("tom",27));
   add(new user("sue",29));
  }};

  list<string> collect = userlist.stream()
    .filter(x -> x.getage() > 27)
    .sorted((a, b) -> a.getage().compareto(b.getage()))
    .limit(2)
    .map(user::getname)
    .collect(collectors.tolist());
  //结果：[curry, sue]
  system.out.println(collect);
 }

4.统计指定集合中，姓名相同的人中年龄最小的年龄

@test
public void testwork4() {
 list<user> userlist = new arraylist<user>() {{
  add(new user("tom", 23));
  add(new user("james", 30));
  add(new user("james", 28));
  add(new user("tom", 27));
  add(new user("sue", 29));
 }};

 userlist.stream().collect(collectors.groupingby(user::getname))
   .foreach((name, list) -> {
    user user = list.stream().sorted((a, b) -> a.getage().compareto(b.getage())).findfirst().orelse(null);
    //结果：name:sue,age:29
    //  name:tom,age:23
    //  name:james,age:28
    system.out.println("name:" + name + ",age:" + user.getage());
   });
}

总结

到此这篇关于java8 stream常用开发技巧的文章就介绍到这了,更多相关java8 stream常用开发技巧内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！