登录 |  注册
首页 >  编程语言 >  java8特性 >  Stream的使用-方法详解（上）

Stream的使用-方法详解（上）

 75  2023-01-16 16:58:23

1.遍历forEach()

返回结果为 void，很明显我们可以通过它来干什么了，比方说：

//打印各个元素：
list.stream().forEach(System.out::println);

再比如说 MyBatis 里面访问数据库的 mapper 方法：

//向数据库插入新元素：
list.stream().forEach(PersonMapper::insertPerson);

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。

2.发现Find()

2.1 findAny() 和 findFirst()

findAny()：找到其中一个元素 (使用 stream() 时找到的是第一个元素；使用 parallelStream()并行时找到的是其中一个元素)

findFirst()：找到第一个元素

值得注意的是，这两个方法返回的是一个 Optional 对象，它是一个容器类，能代表一个值存在或不存在。

3.匹配Match

3.1 anyMatch(T -> boolean)

流中是否有一个元素匹配给定的 T -> boolean 条件

是否存在一个 person 对象的 age 等于 20：

boolean b = list.stream().anyMatch(person -> person.getAge() == 20);

3.2 allMatch(T -> boolean)

流中是否所有元素都匹配给定的 T -> boolean 条件

boolean result = list.stream().allMatch(Person::isStudent);

3.3 noneMatch(T -> boolean)

流中是否没有元素匹配给定的 T -> boolean 条件

boolean result = list.stream().noneMatch(Person::isStudent);

案例

// import已省略，请自行添加，后面代码亦是
public class StreamTest {
public static void main(String[] args) {
        List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
        // 遍历输出符合条件的元素
        list.stream().filter(x -> x > 6).forEach(System.out::println);
        // 匹配第一个
        Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
        // 匹配任意(适用于并行流)
        Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
        // 是否包含符合特定条件的元素
        boolean anyMatch = list.stream().anyMatch(x -> x > 6);
        System.out.println("匹配第一个值：" + findFirst.get());
        System.out.println("匹配任意一个值：" + findAny.get());
        System.out.println("是否存在大于6的值：" + anyMatch);
    }
}


4.筛选filter(T -> boolean)

filter(T -> boolean)：保留 boolean 为 true 的元素。

筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。

筛选出Integer集合中大于7的元素，并打印出来

public class StreamTest {
   public static void main(String[] args) {
      List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
      Stream<Integer> stream = list.stream();
      stream.filter(x -> x > 7).forEach(System.out::println);
    }
}

预期结果：

8 9

5.聚合(max/min/count)

max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。

获取String集合中最长的元素。

public class StreamTest {
            public static void main(String[] args) {
                List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
                Optional<String> max = list.stream().max(Comparator.comparing(String::length));
                System.out.println("最长的字符串：" + max.get());
            }
        }

输出结果：

最长的字符串：weoujgsd

6.映射(map/flatMap)

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：

map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

6.1 map(T -> R)

将流中的每一个元素 T 映射为 R(类似类型转换)

List<String> newlist = list.stream().map(Person::getName).collect(Collectors.toList());

newlist 里面的元素为 list 中每一个 Person 对象的 name 变量。

6.2 flatMap(T -> Stream)

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

List<String> list = new ArrayList<>();
list.add("aaa bbb ccc");
list.add("ddd eee fff");
list.add("ggg hhh iii");
list = list.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(toList());

上面例子中，我们的目的是把 List 中每个字符串元素以” “分割开，变成一个新的 List。

首先 map 方法分割每个字符串元素，但此时流的类型为 Stream。

英文字符串数组的元素全部改为大写。整数数组每个元素+3。

public class StreamTest {
            public static void main(String[] args) {
                String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
                List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
                List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
                List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());
                System.out.println("每个元素大写：" + strList);
                System.out.println("每个元素+3：" + intListNew);
            }
        }

输出结果：

每个元素大写：[ABCD, BCDD, DEFDE, FTR]
每个元素+3：[4, 6, 8, 10, 12, 14]

7.归约(reduce)

归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

7.1 reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)

归约是将集合中的所有元素经过指定运算，折叠成一个元素输出，如：求最值、平均数等，这些操作都是将一个集合的元素折叠成一个元素输出。

在流中，reduce函数能实现归约。

reduce函数接收两个参数：

初始值

进行归约操作的Lambda表达式

用于组合流中的元素，如求和，求积，求最大值等

int age = list.stream().reduce(0, (person1,person2)->person1.getAge()+person2.getAge());
//计算年龄总和：
int sum = list.stream().map(Person::getAge).reduce(0, (a, b) -> a + b);
//与之相同:
int sum = list.stream().map(Person::getAge).reduce(0, Integer::sum);

其中，reduce 第一个参数 0 代表起始值为 0，lambda (a, b) -> a + b 即将两值相加产生一个新值

同样地：

//计算年龄总乘积：
int sum = list.stream().map(Person::getAge).reduce(1, (a, b) -> a * b);

当然也可以

Optional<Integer> sum = list.stream().map(Person::getAge).reduce(Integer::sum);

即不接受任何起始值，但因为没有初始值，需要考虑结果可能不存在的情况，因此返回的是 Optional 类型。

求Integer集合的元素之和、乘积和最大值。

public class StreamTest {
            public static void main(String[] args) {
                List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
                // 求和方式1
                Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
                // 求和方式2
                Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
                // 求和方式3
                Integer sum3 = list.stream().reduce(0, Integer::sum);
                // 求乘积
                Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
                // 求最大值方式1
                Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
                // 求最大值写法2
                Integer max2 = list.stream().reduce(1, Integer::max);
                System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
                System.out.println("list求积：" + product.get());
                System.out.println("list求和：" + max.get() + "," + max2);
            }
        }

输出结果：

list求和：29,29,29
list求积：2112
list求和：11,11

8.收集(collect)

collect，收集方法，我们很常用的是 collect(toList())，当然还有 collect(toSet()) 等，参数是一个收集器接口。收集方法可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。

coollect 方法作为终端操作，接受的是一个 Collector 接口参数，能对数据进行一些收集归总操作。

collect主要依赖java.util.stream.Collectors类内置的静态方法。

8.1 归集(toList/toSet/toMap)

因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet和toMap比较常用，即把流中所有元素收集到一个 List, Set 或 Collection 中，另外还有toCollection、toConcurrentMap等复杂一些的用法。

下面用一个案例演示toList、toSet和toMap：

public class StreamTest {
            public static void main(String[] args) {
                List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
                List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
                Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
                List<Person> personList = new ArrayList<Person>();
                personList.add(new Person("Tom", 8900, 23, "male", "New York"));
                personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
                personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
                personList.add(new Person("Anni", 8200, 24, "female", "New York"));
                Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
                        .collect(Collectors.toMap(Person::getName, p -> p));
                System.out.println("toList:" + listNew);
                System.out.println("toSet:" + set);
                System.out.println("toMap:" + map);
            }


运行结果：

toList：[6, 4, 6, 6, 20]
toSet：[4, 20, 6]
toMap：{Tom=mutest.Person@5fd0d5ae, Anni=mutest.Person@2d98a335}

原文链接: https://www.yukx.com/java/article/details/2348.html 优科学习网Stream的使用-方法详解（上）

<<上一课程
下一课程>>
推荐文章
  • 什么是AQS(Abstract Queued Synchronizer) -抽象队列同步器
         AQS(AbstractQueuedSynchronizer）是一个抽象的队列同步器，通过维护一个共享资源状态（VolatileIntState）和一个先进先出（FIFO）的线程等待队列来实现一个多线程访问共享资源的同步框架。一、AQS原理     AQS为每个共享资源都设置一个共享资源锁
  • word-break: break-all 文本自动换行样式
    word-break:break-all举例一般情况下，元素拥有默认的white-space:normal（自动换行，PS：不换行是white-space:nowrap）,当录入的文字超过定义的宽度后会自动换行，但当录入的数据是一堆没有空格的字符或字母或数字（常规数据应该不会有吧，但有些测试人员是会
  • java.math.BigDecimal 加减乘除计算
    Bigdecimal的初始化这里对比了两种形式，第一种直接value写数字的值，第二种用string来表示        BigDecimal num1 = new BigDecimal(0.005);         BigDecimal num2 = new BigDecimal(1000000
  • JVM浅谈双亲委派模型
    基本概念定义 双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器。双亲委派机制双亲委派机制是指当一个类加载器收到一个类加载请求时，该类加载器首先会把请求委派给父类加载器。每个类加载器都是如此，只有在父类加载器在自己的搜索范围内找不到指定类时，子类加载器才会尝试自己去加载
  • Mybatis无法找到xml文件，Invalid bound statement (not found)
    主要看在resouces目录下的路径和mapper接口的路径是否一致。如接口路径：com.yukx.demo.mapper则在resouces目录下的文件路径：com/yukx/demo/mapper, 而不是如图的那个文件
  • Spring Boot项目中的字体文件问题_Failed to decode downloaded font
    项目页面中字体无法正常显示如下打开调试工具显示如下信息：解决方法查阅相关资料解释说是maven的resource插件开启filtering功能后，会破坏有二进制内容的文件。所以我们可以再pom文件中处理找到resourde节点加上如下代码, 亲测有效：方法一：build         resour
学习大纲
优秀文章
关于我们 免责声明 备案号:闽ICP备19011778号
声明:本站作为学习交流平台，网站内容来网友投稿及互联网收集
若由侵犯到您的权益请发邮件联系我们 我们的邮箱是:yukx2008#sina.com(#换成@)。