JDK8 Stream详解

概念

Stream是Java8 API的新成员，它允许以声明性方式处理数据集合 。

特点

（1）代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。

（2）多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。

流程

1）第一步：把集合转换为流stream
2）第二步：操作stream流
stream流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果

操作符

两种：中间操作符、终止操作符

中间操作符

流方法 含义 示例
filter 用于通过设置的条件过滤出元素 List strings = Arrays.asList(“abc”, “”, “bc”, “efg”, “abcd”,"", “jkl”);List filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
distinct 返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流。 List numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println);
limit 会返回一个不超过给定长度的流。 List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”);List limited = strings.stream().limit(3).collect(Collectors.toList());
skip 返回一个扔掉了前n个元素的流。 List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”);List skiped = strings.stream().skip(3).collect(Collectors.toList());
map 接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）。 List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”);List mapped = strings.stream().map(str->str+"-itcast").collect(Collectors.toList());
flatMap 使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。 List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”);Stream flatMap = strings.stream().flatMap(Java8StreamTest::getCharacterByString);
sorted 返回排序后的流 List strings1 = Arrays.asList(“abc”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);List sorted1 = strings1.stream().sorted().collect(Collectors.toList());

示例代码：

1）filter

/*** 功能描述:根据条件过滤集合数据* @return : void*/
@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());out.println(filtered);
}

2）distinct

/*** 功能描述:去除集合中重复数据* @return : void*/
@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());out.println(distincted);
}

3）limit

/*** 功能描述:指定获取集合前x条数据，重新构造一个新的集合* @return : void*/
@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());out.println(limited);
}

4）skip

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

5）map

/*** 功能描述:对集合中所有元素统一处理* @return : void*/
@Test
public void map(){List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");List<String> mapped = strings.stream().map(str->str+"-itcast").collect(Collectors.toList());out.println(mapped);
}

6）flatMap

/*** 功能描述:对集合中所有元素统一处理* @return : void*/
@Test
public void flatMap(){List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");Stream<String> stringStream = strings.stream().map(x -> x);Stream<String> stringStream1 = strings.stream().flatMap(x -> Arrays.asList(x.split(" ")).stream());
}

7）sorted

/*** 功能描述 : 对集合进行排序* @return : void*/
@Test
public void sorted(){List<String> strings1 = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");List<String> strings2 = Arrays.asList("张三", "李四", "王五", "赵柳", "张哥","李哥", "王哥");List<Integer> strings3 = Arrays.asList(10, 2, 30, 22, 1,0, -9);List<String> sorted1 = strings1.stream().sorted().collect(Collectors.toList());List<String> sorted2 = strings2.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());List<Integer> sorted3 = strings3.stream().sorted().collect(Collectors.toList());out.println(sorted1);out.println(sorted2);out.println(sorted3);
}

Map、flatMap区别

map：对流中每一个元素进行处理
flatMap：流扁平化，让你把一个流中的“每个值”都换成另一个流，然后把所有的流连接起来成为一个流
总结：map是对一级元素进行操作，flatmap是对二级元素操作。

本质区别：map返回一个值；flatmap返回一个流，多个值。

应用场景：map对集合中每个元素加工,返回加工后结果；flatmap对集合中每个元素加工后，做扁平化处理后（拆分层级，放到同一层）然后返回


/*** 方法一* 功能描述:  通过使用map、flatMap把字符串转换为字符输出对比区别* @return : void*/
@Test
public void flatMap2Map(){List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");final Stream<Character> flatMap = strings.stream().flatMap(Java8StreamTest::getCharacterByString);flatMap.forEach(System.out::println);//----------------------------------------------final Stream<Stream<Character>> mapStream = strings.stream().map(Java8StreamTest::getCharacterByString);//mapStream.forEach(System.out::println);out.println("------------------------------------------------");mapStream.forEach(stream-> {stream.forEach(character->{System.out.println(character);});});}

公共方法（字符串转换为字符流）

/**
* 功能描述:字符串转换为字符流
* @param str
* @return : java.util.stream.Stream<java.lang.Character>
*/
public static Stream<Character> getCharacterByString(String str) {List<Character> characterList = new ArrayList<>();for (Character character : str.toCharArray()) {characterList.add(character);}return characterList.stream();
}

终止操作符

流方法 含义 示例
anyMatch 检查是否至少匹配一个元素，返回boolean。 List strings = Arrays.asList(“abc”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);boolean b = strings.stream().anyMatch(s -> s == “abc”);
allMatch 检查是否匹配所有元素，返回boolean。 List strings = Arrays.asList(“abc”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);boolean b = strings.stream().allMatch(s -> s == “abc”);
noneMatch 检查是否没有匹配所有元素，返回boolean。 List strings = Arrays.asList(“abc”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);boolean b = strings.stream().noneMatch(s -> s == “abc”);
findAny 将返回当前流中的任意元素。 List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);Optional any = strings.stream().findAny();
findFirst 返回第一个元素 List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);Optional first = strings.stream().findFirst();
forEach 遍历流 List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);strings.stream().forEach(s -> out.println(s));
collect 收集器，将流转换为其他形式。 List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);Set set = strings.stream().collect(Collectors.toSet());List list = strings.stream().collect(Collectors.toList());Map<String, String> map = strings.stream().collect(Collectors.toMap(v ->v.concat("_name"), v1 -> v1, (v1, v2) -> v1));
reduce 可以将流中元素反复结合起来，得到一个值。 List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);Optional reduce = strings.stream().reduce((acc,item) -> {return acc+item;});if(reduce.isPresent())out.println(reduce.get());
count 返回流中元素总数。 List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);long count = strings.stream().count();

示例代码

1）anyMatch

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

2）allMatch

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

3）noneMatch

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

4）findAny

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

5）findFirst

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

6）forEach java

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

7）collect

/*** 功能描述 : 流转换为其他形式* @return : void*/
@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());Map<String, String> map = strings.stream().collect(Collectors.toMap(v ->v.concat("_name"), v1 -> v1, (v1, v2) -> v1));out.println(set);out.println(list);out.println(map);
}

8）reduce

/*** 功能描述 : 将流中元素反复结合起来，得到一个值* @return : void*/
@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) -> {return acc+item;});//reduce方法二String reduce2 = strings.stream().reduce("itcast", (acc, item) -> {return acc + item;});//reduce方法三ArrayList<String> reduce3 = strings.stream().reduce(new ArrayList<String>(),new BiFunction<ArrayList<String>, String, ArrayList<String>>() {@Overridepublic ArrayList<String> apply(ArrayList<String> acc, String item) {acc.add(item);return acc;}}, new BinaryOperator<ArrayList<String>>() {@Overridepublic ArrayList<String> apply(ArrayList<String> acc, ArrayList<String> item) {return acc;}});if(reduce1.isPresent())out.println(reduce1.get());out.println(reduce2);out.println(reduce3);
}

9）count

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

Java中的Stream流详解相关推荐

  1. Java中的static关键字详解

    ** Java中的static关键字详解 ** 在一个类中定义一个方法为static,即静态的,那就是说无需本类的对象就可以调用此方法.调用一个静态方法就是 "类名.方法名" ,静 ...

  2. java中properties作用,Java中Properties的使用详解

    Java中有个比较重要的类Properties(Java.util.Properties),主要用于读取Java的配置文件,各种语言都有自己所支 持的配置文件,配置文件中很多变量是经常改变的,这样做也 ...

  3. java中的进制输出转换_Java I/O : Java中的进制详解

    作者:李强强 上一篇,泥瓦匠基础地讲了下Java I/O : Bit Operation 位运算.这一讲,泥瓦匠带你走进Java中的进制详解. 一.引子 在Java世界里,99%的工作都是处理这高层. ...

  4. Java中的main()方法详解

    源文作者:leizhimin    源文链接:http://lavasoft.blog.51cto.com/62575/53263 源文作者版权申明: 版权声明:原创作品,允许转载,转载时请务必以超链 ...

  5. java中Freemarker list指令详解

    java Freemarker中list指令主要是进行迭代服务器端传递过来的List集合. 定义 <#list nameList as names> ${names} </#list ...

  6. Java中的Runtime类详解

    Java中的Runtime类详解 1.类注释 /**Every Java application has a single instance of class Runtime that allows ...

  7. Java 中的伪共享详解及解决方案

    转载自  Java 中的伪共享详解及解决方案 1. 什么是伪共享 CPU 缓存系统中是以缓存行(cache line)为单位存储的.目前主流的 CPU Cache 的 Cache Line 大小都是 ...

  8. java中list和map详解

    java中list和map详解 一.概叙 List , Set, Map都是接口,前两个继承至Collection接口,Map为独立接口, List下有ArrayList,Vector,LinkedL ...

  9. stringtokenizer java_基于Java中的StringTokenizer类详解(推荐)

    StringTokenizer是字符串分隔解析类型,属于:Java.util包. 1.StringTokenizer的构造函数 StringTokenizer(String str):构造一个用来解析 ...

最新文章

  1. Numpy的基本操作
  2. win7中安装mysql_windows7下安装Mysql5.6数据库图文教程（压缩包安装）
  3. CentOS镜像下载地址
  4. php xml expat,PHP 使用 XML Expat 解释xml文件
  5. 利用posix_fadvise清理系统中的文件缓存
  6. ipv6 访问内网_【内网渗透】—— 隐藏通信隧道技术之网络层隧道技术
  7. 1.5 基础数据类型 -- 字典与集合
  8. socket通信基础知识
  9. .NET简谈自定义事务资源管理器
  10. Windows Server 8 Beta 初体验之二：Hyper-v
  11. html 中加载字体太慢,css字体文件包太大无法引入怎么处理？
  12. MDClub 轻量级网论坛源码
  13. linux tc 限制带宽,使用TC 对LINUX服务器网卡进行带宽限制的办法
  14. Processing编写熊猫
  15. sh: /node_modules/.bin/vue-cli-service: Permission denied
  16. 利用 Eclipse Visual Editor 项目构建 GUI 应用程序
  17. 一个好用的源代码阅读工具——Understand
  18. Vue项目之上传图片
  19. 用程序编写计算公式的高次方程数字计算机
  20. 软件开发公司的提成制度【修订中】

热门文章

  1. 计算机科学5个学科领域,想学计算机吗？快看计算机专业领域TOP10高校大盘点
  2. dell 灵越N5110 拆机
  3. android icu4c 7.1编译报错,icu4c中资源的修改，编译
  4. 牙痛用药口决(来源于网络暂未验证)
  5. Java面试含答案(最全版)
  6. Load Switch介绍与使用
  7. element upload组件，ctrl v粘贴图片自动上传
  8. 浅谈Linux tty体系，理清tty驱动层次与各种概念
  9. 2023发卡网 自动发卡系统源码+商家入驻
  10. xampp、lamp、lampp