JAVA8 Stream接口流式方法 map操作 filter操作以及flatMap操作

 

   关于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 = { 1, 2, 3 };
		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/

 

 
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页