Java8中的Stream 流实践操作

目录
  • 1 前言
  • 2 Stream 的分类
  • 3 Stream 的操作
    • 3.1 创建流的方式
    • 3.2 流的中间操作
    • 3.3 流的终止操作
  • 总结

1 前言

Stream 是 java8 中处理集合的抽象概念,可以执行非常复杂的查询、过滤和映射数据等操作。Stream API 提供了一种高效的处理数据方式,Stream 对集合数据的操作可以说是非常的方便。Stream 是流,不是一种数据结构,也不会保存数据,只是一种数据处理方式,从一种数据组织结构到另外一种数据结构。

2 Stream 的分类

按照 Stream 的,可以分为以下集中方式:

  • 1 中间操作无状态,指元素的处理不受之前元素的影响。
  • 2 中间操作有状态,等到获取所有元素之后才能继续进行处理。
  • 3 最终操作非短路操作,必须处理所有元素后才能得到最终结果。
  • 4 最终操作短路操作,当遇到符合条件的元素就可以拿到最终结果。

3 Stream 的操作

3.1 创建流的方式

关于流的创建方式,可以使用数组或者集合,流的形式分为顺序流和并行流。

具体如下所示:

// 数组形式获取流
String[] dataArrs = new String[10];
Stream<String> stream = Arrays.stream(dataArrs);
// 集合方式创建
List<String> dataList = new ArrayList<>();
// 获取一个顺序流
Stream<String> stream = dataList.stream();
 // 获取一个并行流
Stream<String> parallelStream = dataList.parallelStream();

当然处理上述的形式之外,也可以使用 Stream 的内置方法 generate()、of()、iterate() 来创建。

// of 创建 stream
Stream<String> strs = Stream.of("a","b","c","d");
// lambda 创建等差数列,获取前 3 个
Stream<Integer> stream2 = Stream.iterate(1, (x) -> x + 4).limit(3);
stream2.forEach(System.out::println); // 1 5 9
// 随机获取三个随机数
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

3.2 流的中间操作

关于流的中间操作,主要分为以下几种:

  • 1 筛选操作与切片, filter 过滤流中的某些元素,limit 获取某几个元素,skip 跳过某些元素,通常和 limit 配合使用实现分页操作。distinct 通常用来实现去重操作。
  • 2 映射操作, map 和 flatmap , 两者都是接受一个函数为函数,前者是映射到一个元素,后者则是将一个元素映射成一个流。
  • 3 排序操作,这里就很好理解,就是 sorted 操作。
Stream<String> strs = Stream.of("a","b","c","d","d","e","f");
// 过滤大于b 的字符串并进行去重操作,跳过前两个并选取两个进行输出
Stream<String> result = strs.filter(s -> s.compareTo("b") > 0)
                .distinct()
                .skip(2)
                .limit(2);
// 输出结果 e 和 f
result.forEach(System.out::println);
// flatMap 的操作
List<String> list = Arrays.asList("e,f,g", "1,2,3");
// 利用map去除每个元素中的逗号
Stream<String> st1 = list.stream().map(s -> s.replaceAll(",", ""));
st1.forEach(System.out::println); // efg  123
// 利用 flatMap 将字符串进行分割
Stream<String> st2 = list.stream().flatMap(ele -> {
    //将每个元素转换成一个stream
    String[] split = ele.split(",");
    return Arrays.stream(split);
});
st2.forEach(System.out::println); // e f g 1 2 3
// 排序操作
List<String> list = Arrays.asList("aa", "ff", "dd");
//String 类自身已实现Compareable接口 aa dd ff
list.stream().sorted().forEach(System.out::println);

3.3 流的终止操作

  • 1 stream 匹配和聚合操作。匹配相关的 allMatch、noneMatch、anyMatch 三者都是接受一个 Predicate 函数,当每个元素都满足、都不满足、只要有一个元素满足,并返回断言结果。统计相关,count、sum、 max 、min 。findFirst 和 findAny 为查找第一个或者任意一个元素进行返回。
  • 2 规约操作, reduce ,这是一个不太好理解的概念,从数学角度来说,reduce 接受的是一个函数是一个推导式,类似于 a_j = a_i + 1, j = i+1aj​=ai​+1,j=i+1
  • 3 收集操作,即 collect, 当所有的数据都处理完毕后,需要将数据进行处理,通常而言,获取的结果就是 set 、list 或者 map。
// match 操作 findFirst  findAny  count max min 操作
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// 返回结果 false
boolean allMatch = list.stream().allMatch(e -> e > 10);
// 返回结果 true
boolean noneMatch = list.stream().noneMatch(e -> e > 10);
// 返回结果 true
boolean anyMatch = list.stream().anyMatch(e -> e > 4);
// 查找第一个或者随机获取
Integer findFirst = list.stream().findFirst().get();
Integer findAny = list.stream().findAny().get();
// 统计数据 个数为 5 最大值为 5 最小值为 1
long count = list.stream().count();
Integer max = list.stream().max(Integer::compareTo).get();
Integer min = list.stream().min(Integer::compareTo).get();
// reduce 操作
List<Integer> list = Arrays.asList(1, 2, 3);
// 该操作即是 累加求和,结果为 6
Integer result = list.stream().reduce((x1, x2) -> x1 + x2).get();
System.out.println(result);
// 标签
List<String> tags1 = Lists.newArrayList("a", "b", "c");
List<String> tags2 = Lists.newArrayList("d", "e", "f");
// 创建对象
User user1 = new User("小明", 12, tags1, BigDecimal.valueOf(43));
User user2 = new User("小李", 14, tags2, BigDecimal.valueOf(43));
// 声明数组对象
List<User> userList = Lists.newArrayList(user1, user2);
// 年龄和体重数据
List<Integer> ageList = userList.stream().map(User::getAge).collect(Collectors.toList());
Set<BigDecimal> weightSet = userList.stream().map(User::getWeight).collect(Collectors.toSet());
// 建立姓名年龄映射
Map<String, Integer> nameAgeMap = userList.stream().collect(Collectors.toMap(User::getName,User::getAge, (k1, k2) -> k2));
// flatMap 获取所有的标签
List<String> tagsList = userList.stream().flatMap(node -> node.getTags().stream().map(String::intern)).distinct().collect(Collectors.toList());
// 按照年龄分组
Map<Integer, List<User>> ageMap = userList.stream().collect(Collectors.groupingBy(User::getAge));
// 分区分成两部分,一部分大于10岁,一部分小于等于10岁
Map<Boolean, List<User>> partMap = userList.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 10));
//规约 reduce
Integer sumAge = userList.stream().map(User::getAge).collect(Collectors.reducing(Integer::sum)).get();

总结

文中讲述了 stream 流相关的操作,从流的创建到操作,都从实际的应用出发进行了数据展示,在诸多的方法中,reduce 是一个不太好理解的概念,这个需要结合应用场景进行分析。

到此这篇关于Java8中的Stream 流实践操作的文章就介绍到这了,更多相关Java8 Stream 内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java8之Stream流代替For循环操作

    Stream流代替For循环进行输出可以使代码更简洁. 需求:根据姓名获取员工信息 1.建立实体类:Emp public class Emp { private String id; private String name; public Emp(String id, String name) { this.id=id; this.name=name; } public String getId() { return id; } public void setId(String id) { th

  • java8新特性之stream流中reduce()求和知识总结

    1.stream().reduce()单字段求和 (1)普通数字求和 public static void test2(){ List<Integer> list= Arrays.asList(new Integer[]{1,2,3,4,5,6,7,8,9}); Integer sum=list.stream().reduce((x,y)->x+y).get(); System.out.println(sum); } 2.BigDecimal求和 public static void m

  • 基于Java8并行流(parallelStream)的注意点

    Java8并行流(parallelStream)注意点 在最初使用并行流的时候,查询列表会偶尔性报空指针异常,这令我非常纳闷 代码是这样的: List<OrderListVO> orderListVOS = new LinkedList<OrderListVO>(); baseOrderBillList.parallelStream().forEach(baseOrderBill -> { OrderListVO orderListVO = new OrderListVO()

  • 总结一下关于在Java8中使用stream流踩过的一些坑

    Java8的stream流 第一个坑: Collectors.toAsList()其实是new了一个list,在向里面赋值. 注意这里Collectors.toList()的写法,这里其实是底层new ArraryList().筛选的数据放到一个新的list.虽然标1处和标2处是同一个变量,但是内存地址是不一样啊.下面的逻辑时把hldrPolVOList中的某些元素删除.但是这个方法执行完后其实是没有删除里面元素的.原因就是这里的new ArraryList()更改了内存地址造成的. 测试: 解

  • Java8 Stream 流常用方法合集

    目录 一.概述 二.分类 三.具体用法 1. 流的常用创建方法 2. 流的中间操作 3. 流的终止操作 一.概述 Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找.过滤和映射数据等操作.使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询.也可以使用 Stream API 来并行执行操作. 简而言之,Stream API 提供了一种高效且易于使用的处理数据的方式. 特点: 不是数据结构,不会保存数据.

  • java8新特性 stream流的方式遍历集合和数组操作

    前言: 在没有接触java8的时候,我们遍历一个集合都是用循环的方式,从第一条数据遍历到最后一条数据,现在思考一个问题,为什么要使用循环,因为要进行遍历,但是遍历不是唯一的方式,遍历是指每一个元素逐一进行处理(目的),而并不是从第一个到最后一个顺次处理的循环,前者是目的,后者是方式. 所以为了让遍历的方式更加优雅,出现了流(stream)! 1.流的目的在于强掉做什么 假设一个案例:将集合A根据条件1过滤为子集B,然后根据条件2过滤为子集C 在没有引入流之前我们的做法可能为: public cl

  • Java8特性之用Stream流代替For循环操作详解

    目录 准备一个实体类 准备一个List集合 传统的for循环 使用Stream流 先声明筛选条件,在遍历 Stream操作 嵌套循环(2层) 准备一个实体类 public class Student { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int get

  • Java8中的Stream 流实践操作

    目录 1 前言 2 Stream 的分类 3 Stream 的操作 3.1 创建流的方式 3.2 流的中间操作 3.3 流的终止操作 总结 1 前言 Stream 是 java8 中处理集合的抽象概念,可以执行非常复杂的查询.过滤和映射数据等操作.Stream API 提供了一种高效的处理数据方式,Stream 对集合数据的操作可以说是非常的方便.Stream 是流,不是一种数据结构,也不会保存数据,只是一种数据处理方式,从一种数据组织结构到另外一种数据结构. 2 Stream 的分类 按照 S

  • Java8中的Stream流式操作教程之王者归来

    前言 相对于Java8之前的Java的相关操作简直是天差地别,Java8 的流式操作的出现,也很大程度上改变了开发者对于Java的繁琐的操作的印象,从此,Java也走向了函数式编程的道路! 1 流的创建 1.1 流的创建方法 既然需要聊聊流的操作,那么,首先还是先看看怎么创建流. 创建流的方法有三种,分别是:Stream.of().Stream.iterate().Stream.generate(),然后,分别看一下这三个方法的声明. static <T> Stream<T> of

  • Java8新特性Stream流实例详解

    什么是Stream流? Stream流是数据渠道,用于操作数据源(集合.数组等)所生成的元素序列. Stream的优点:声明性,可复合,可并行.这三个特性使得stream操作更简洁,更灵活,更高效. Stream的操作有两个特点:可以多个操作链接起来运行,内部迭代. Stream可分为并行流与串行流,Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换.串行流就不必再细说了,并行流主要是为了为了适应目前多核机器的时代,提高系统CP

  • 详解java8中的Stream数据流

    Stream是java8引入的一个重度使用lambda表达式的API.Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象.直观意味着开发者在写代码时只需关注他们想要的结果是什么而无需关注实现结果的具体方式.这一章节中,我们将介绍为什么我们需要一种新的数据处理API.Collection和Stream的不同之处以及如何将StreamAPI应用到我们的编码中. 筛选重复的元素 Stream 接口支持 distinct 的方法, 它会返回一个元素

  • 初识Java8中的Stream

    lambda表达式是stream的基础,初学者建议先学习lambda表达式,http://www.jb51.net/article/121129.htm 1.初识stream 先来一个总纲: 东西就是这么多啦,stream是java8中加入的一个非常实用的功能,最初看时以为是io中的流(其实一点关系都没有),让我们先来看一个小例子感受一下: @Before public void init() { random = new Random(); stuList = new ArrayList<St

  • JDK1.8新特性Stream流式操作的具体使用

    一. 前言 随着Java的发展,越来越多的企业开始使用JDK1.8 版本.JDK1.8 是自 JDK1.5之后最重要的版本,这个版本包含语言.编译器.库.工具.JVM等方面的十多个新特性.本次文章将着重学习Stream. Stream 是JDK1.8 中处理集合的关键抽象概念,Lambda 和 Stream 是JDK1.8新增的函数式编程最有亮点的特性了,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找.过滤和映射数据等操作.使用Stream API 对集合数据进行操作,就类似于使用SQ

  • java8中Map的一些骚操作总结

    一 前言 本篇内容是关于 map 新特性的一些方法使用上的介绍,如果有不足之处欢迎补充!! 二 map新特性 关于以下函数式编程的函数的计算知识追寻者都使用 简单字符串代替了,参数无非就是Key,value: 2.1 forEach forEach迭代,相当于for循环 public static void main(String[] args) { HashMap<String, Object> hashMap = new HashMap<>(); hashMap.put(&qu

  • Java8 中使用Stream 让List 转 Map使用问题小结

    在使用 Java 的新特性 Collectors.toMap() 将 List 转换为 Map 时存在一些不容易发现的问题,这里总结一下备查. 空指针风险 java.lang.NullPointerException 当 List 中有 null 值的时候,使用 Collectors.toMap() 转为 Map 时,会报 java.lang.NullPointerException,如下: List<SdsTest> sdsTests = new ArrayList<>(); S

随机推荐