Java8 Stream接口流式方法:map操作、filter操作以及flatMap操作

>>强大,10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程!

点击关注公众号,利用碎片时间学习

关于stream 流式操作,在rt.jar 包里面,ReferencePipeline管道方式操作数据 下面集成所有操作方法,利用这些流,处理大数据的方式,效率提升明显,并且很多语言都支持这种操作,相当于统一了这种编程方式。

我们先来看看这三个操作过滤的是什么数据,

过滤之后仍然可以循环数据

list.stream().filter(smap -> null != smap.get("ip") && !"".equals(smap.get("ip"))).forEach(imp -> {
   listipzone.add(wry.findIP(imp.get("ip").toString()));
});
1,filter操作,我们先看方法的定义

源码如下Stream<T> filter(Predicate<? super T> predicate);一个单纯的过滤操作直接返回传入类型

String[] dd = { "a""b""c" };
        Stream<String> stream = Arrays.stream(dd);
        stream.filter(str -> str.equals("a")).forEach(System.out::println);
        //返回字符串为a的值
2.map操作,先看方法定义

源码如下  <R> Stream<R> map(Function<? super T, ? extends R> mapper);

这个方法传入一个Function的函数式接口,这个接口,接收一个泛型T,返回泛型R,map函数的定义,返回的流,表示的泛型是R对象,这个表示,调用这个函数后,可以改变返回的类型

 public static void main(String[] args) {
  Integer[] dd = { 123 };
  Stream<Integer> stream = Arrays.stream(dd);
  stream.map(str -> Integer.toString(str)).forEach(str -> {
   System.out.println(str);// 1 ,2 ,3
   System.out.println(str.getClass());// class java.lang.String
  });
 
  List<Emp> list = Arrays.asList(new Emp("a"), new Emp("b"), new Emp("c"));
  list.stream().map(emp -> emp.getName()).forEach(str -> {
   System.out.println(str);
  });
 
 }
 
 public static class Emp {
  private String name;
 
  public Emp() {
   super();
  }
 
  public Emp(String name) {
   super();
   this.name = name;
  }
 
  public String getName() {
   return name;
  }
 
  public void setName(String name) {
   this.name = name;
  }
 
 }

可以看到,我们把Integer,变成了String输出,把Emp对象里的name字符串,单独输出;现在,我们只看到了一个forEach的终端操作,后面,我们会看到,更多的终端操作,把map操作后,改变的对象类型,返回各种类型的集合,或者对数字类型的,返回求和,最大,最小等的操作;

3.flatMap操作,我们还是先看接口定义

包含前面两种过滤类型

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

这个接口,跟map一样,接收一个Fucntion的函数式接口,不同的是,Function接收的泛型参数,第二个参数是一个Stream流;方法,返回的也是泛型R,具体的作用是把两个流,变成一个流返回,下面,我们看一个案例,来详细解答,怎么把两个流的内容,变成一个流的内容

public static void main(String[] args) {
  String[] strs = { "aaa""bbb""ccc" };
  Arrays.stream(strs).map(str -> str.split("")).forEach(System.out::println);// Ljava.lang.String;@53d8d10a
  Arrays.stream(strs).map(str -> str.split("")).flatMap(Arrays::stream).forEach(System.out::println);// aaabbbccc
  Arrays.stream(strs).map(str -> str.split("")).flatMap(str -> Arrays.stream(str)).forEach(System.out::println);// aaabbbccc
 }

首先,第二段代码,才输出的具体的字符串;

第一段输出代码里,我们先看map操作,通过上面对map的介绍,我们可以看到,map可以改变返回的Stream的泛型,str.split(""),根据空字符串分隔,返回的类型是一个数组,返回的流也是Stream<String[]>,而不是Stream<String>;在第二段代码中,数组的流,经过map操作,返回Stream<String[]>后,再经过flatMap,把数组通过Arrays.stream变成一个新的流,再返回到原来的流里;这样,两个流就合并成一个流;第三段代码,是第二段代码的,另一种写法;

PS  简单操作示例   1filter 过滤,2 map可以返回其它类型,3 flatMap合并两个流数据

String[] includes=new String[10];
 includeList.toArray(includes);
 List<String> maplist =  includeList.stream().map(s -> s.equals("a6")?"a6L":s).collect(Collectors.toList());
 List<String> filterlist = includeList.stream().filter(s -> s.equals("a6")).collect(Collectors.toList());
 includeList.stream().map(s -> s.equals("a6")?"a6L":s).forEach(System.out::println);//直接操作里面的数据, 改变逻辑后可以返回list等
 filterlist.forEach(System.out::println);// 只打印a6过滤的数据
 maplist.forEach(System.out::println);
4  构造流的几种常见方法
Stream stream = Stream.of("a""b""c");
 
// 2. Arrays
 
String [] strArray = new String[] {"a""b""c"};
 
stream = Stream.of(strArray);
 
stream = Arrays.stream(strArray);
 
// 3. Collections
 
List<String> list = Arrays.asList(strArray);
 
stream = list.stream();
 
// map对象进行 排序对比,最主要还是要把数字转化为 Integer类型去比较,否则只是字符串比较,无意义,封装成一个可比较的数据类型,转化字符串为数字类型 就可能排序了
    model.put("data", listMap.stream()
                .sorted((a, b) -> Integer.valueOf(b.get("count").toString()).compareTo(Integer.valueOf(a.get("count").toString())))
5 流转换为其它数据结构
// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();
//分组构造Map
Map<Integer, String> factoryMap = factoryConfigDOS.stream().collect( Collectors.groupingBy(AgencyDailySalaryFactoryConfigDO::getFenceId, Collectors.mapping(AgencyDailySalaryFactoryConfigDO::getFactoryName, joining(",")) ));
 
//Map转化  函数表达式转成MAP,key1和key2重复就覆盖不然会报错
Map nameMap = incumbentExcelInfoList.stream().collect(Collectors.toMap(info -> info.getIdCard(), info -> info.getName(),(key1,key2)->key2)); 

一个 Stream 只可以使用一次

很多API都有这种方式的操作,对后期大数据或者其它语言兼容,解决跨语言的问题,也提交了效率,日后要以这种方式处理数据,

6 流的操作

接下来,当把一个数据结构包装成 Stream 后,就要开始对里面的元素进行各类操作了。常见的操作可以归类如下。

Intermediate:  (中间)
map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
 
Terminal:(终端)
forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
 
Short-circuiting:(短路)
anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limi

limit/skip

limit 返回 Stream 的前面 n 个元素;skip 则是扔掉前 n 个元素(它是由一个叫 subStream 的方法改名而来)。

List<String> personList2 = persons.stream().
map(Person::getName).limit(10).skip(3).collect(Collectors.toList());
 System.out.println(personList2);

所有 Stream 的操作必须以 lambda 表达式为参数

merge为Map接口新增的默认方法

// k-8值存在为value8->执行merge函数->直接返回"NewMerge8"->newValue为"NewMerge8"
// 执行put->所以这里输出"NewMerge8"
map.merge(8"merge", (value, newValue) -> "NewMerge8");
System.out.println(map.get(8));
 
// 合并方式
String newValue2 = map.merge(9"concat", (value, newValue) -> value.concat(newValue));
 
// 解释:从字符串序列中过滤出以字符a开头的字符串并迭代打印输出
stringList.stream().filter((s) -> s.startsWith("a")).forEach(System.out::println);

组合查询  主要是peek 监视消费后执行的动作

List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
System.out.println(“sum is:”+nums.stream().filter(num -> num != null).
           distinct().mapToInt(num -> num * 2).
            peek(System.out::println).skip(2).limit(4).sum());

Integer类型的List,获取其对应的Stream对象,然后进行过滤掉null,再去重,再每个元素乘以2,再每个元素被消费的时候打印自身,在跳过前两个元素,最后去前四个元素进行加和运算

7 数据并行化操作

Stream 的并行化也是 Java 8 的一大亮点。数据并行化是指将数据分成块,为每块数据分配单独的处理单元。这样可以充分利用多核 CPU 的优势。

并行化操作流只需改变一个方法调用。如果已经有一个 Stream 对象,调用它的 parallel()方法就能让其拥有并行操作的能力。如果想从一个集合类创建一个流,调用 parallelStream() 就能立即获得一个拥有并行能力的流。

int sumSize = Stream.of("Apple""Banana""Orange""Pear") .parallel() .map(s -> s.length()) .reduce(Integer::sum) .get(); assertEquals(sumSize, 21);

详情API参考

https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/

来源:blog.csdn.net/limingcai168/article/details/85265089

推荐:

主流Java进阶技术(学习资料分享)

Java8 Stream接口流式方法:map操作、filter操作以及flatMap操作
PS:因为公众号平台更改了推送规则,如果不想错过内容,记得读完点一下“在看”,加个“星标”,这样每次新文章推送才会第一时间出现在你的订阅列表里。“在看”支持我们吧!

原文始发于微信公众号(Java笔记虾):Java8 Stream接口流式方法:map操作、filter操作以及flatMap操作