JDK8（三）Java Stream API

其他 2020-04-03 11:07:11 阅读次数: 0

文章目录

一、什么是Java Stream API？

1.1、简介

Java Stream函数式编程接口最初是在Java 8中引入的，并且与lambda一起成为Java开发的里程碑式的功能特性，它极大的方便了开放人员处理集合类数据的效率。
Java Stream就是一个数据流经的管道，并且在管道中对数据进行操作，然后流入下一个管道。
管道的功能包括：Filter（过滤）、Map(映射)、sort(排序）等，集合数据通过Java Stream管道处理之后，转化为另一组集合或数据输出。
在这里插入图片描述

二、如何获取Stream流？

（完整代码在下面，放到一个类里面了）

package com.zicheng.stream;

import java.util.*;
import java.util.stream.Stream;

/**
 * 子诚
 * Description：集合、map、数组 获取流
 * 时间：2020/4/1 16:44
 */
public class Demo_GetStream {
    public static void main(String[] args) {
        //list获取Stream流
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        //set获取Stream流
        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

        //获取Map的Stream流
        Map<String, String> map = new HashMap<>();
        //获取map中 key 的Stream流
        Stream<String> keyStream = map.keySet().stream();
        //获取map中 value 的Stream流
        Stream<String> valueStream = map.values().stream();
        //获取 entry 的Stream流
        Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();

        //数组获取Stream流
        String[] array = {"河南省", "新乡市", "河南师范大学"};
        Stream<String> arrayStream = Stream.of(array);
    }
}

2.1、Collection 转换为管道流

注：
java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流。

关键代码：
list.stream(); set.stream();

2.2、Map 转换为管道流

注：
java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以需要分别获取对应的流；需要分key、value或entry等情况。

关键代码：
map.keySet().stream();
map.values().stream();
map.entrySet().stream();

3.3、数组转换为管道流

注：
如果使用的不是集合（Collection）或映射（map）而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法 of

关键代码：
Stream.of(array);

3.4、文本文件转换为管道流

通过Files.lines方法将文本文件转换为管道流，下图中的Paths.get()方法作用就是获取文件，是Java NIO的API！

Stream<String> lines = Files.lines(Paths.get("file.txt"));

三、常用方法

3.0、全部代码

package com.zicheng.stream;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toList;

/**
 * 子诚
 * Description：Stream中的常用方法
 * 时间：2020/4/1 18:27
 */
public class StreamFunctionDemo {
    public static void main(String[] args) {
        StreamFunctionDemo demo = new StreamFunctionDemo();
        //方法1：逐一处理：forEach
        demo.test_forEach();

        //方法2：过滤：filter
        demo.test_filter();

        //方法3：映射：map
        demo.test_map();

        //方法4：排序：sorted
        demo.test_sorted();

        //方法6：统计个数test_count()
        demo.test_count();
        
        //方法7：测试截取：limit
        demo.test_limit();
        
        //方法8：跳过：skip
        demo.test_skip();
        
        //方法9：组合：concat
        demo.test_concat();
    }

    //方法1：逐一处理：forEach
    void test_forEach() {
        String[] array = {"河南省", "新乡市", "河南师范大学"};
        Stream<String> arrayStream = Stream.of(array);
        /**
         * parallel()函数表示对管道中的元素进行并行处理而不是串行处理。
         * 但是这样就有可能导致管道流中后面的元素先处理，前面的元素后处理，也就是元素的顺序无法保证。
         * 数据量大的话，就能观察到数据顺序是无法保证的.
         * 不想用，不用
         */
        arrayStream.parallel().forEach(item -> System.out.println(item));

        arrayStream.forEach(item -> {
            //在这个地方可以对每个item进行操作
            System.out.println(item);
        });
    }

    //方法2：过滤：filter
    void test_filter() {
        // 获取以“河南”开头的数据项
        List<String> nameStrs = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> list = nameStrs.stream()
                .filter(s -> s.startsWith("河南"))
                // 转换成了List的数据结构，方便接收和打印
                .collect(toList());
        System.out.println(list);
    }

    //方法3：映射：map；将集合中的每一个字符串全部大写
    void test_map() {
        // Arrays.asList(),将数组转换为字符串
        List<String> players = Arrays.asList("Kobe Bean Bryant", "James", "Harden", "Curry", "Durant");
        List<String> list = players.stream()
                //s-> s.toUpperCase(),可以替换为String::toUpperCase(方法引用)
                .map(String::toUpperCase)
                // 转换成了List的数据结构，方便接收和打印
                .collect(toList());
        System.out.println(list);
    }

    //方法4：排序：sorted
    void test_sorted() {
        List<Integer> nums = Arrays.asList(2, 6, 5, 4, 8, 7, 9);
        //sorted，默认是升序
        List<Integer> list = nums.stream().sorted().collect(toList());
        System.out.println(list);
        //如果想要降序的话
        Collections.reverse(list);
        System.out.println(list);
    }

    //方法5：转换：collect
    void test_collect() {
        //list，set可以互转。
        //list转成map的话，index当做key，元素就当做value
        //具体，有时间再写
    }

    //方法6：统计个数：count
    void test_count() {
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        long count = school.stream()
                .filter(s -> s.startsWith("河南"))
                .count();
        //打印个数
        System.out.println(count);
    }

    //方法7：截取：limit
    void test_limit() {
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> limit = school.stream()
                .limit(2)
                .collect(toList());
        //打印结果
        System.out.println(limit);
    }

    //方法8：跳过：skip
    void test_skip() {
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> skip = school.stream()
                //跳过前两个
                .skip(2)
                .collect(toList());
        //打印结果
        System.out.println(skip);
    }

    //方法9：组合：concat
    void test_concat() {
        List<String> country = Arrays.asList("地球", "中华人民共和国");
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        //将上面的两个集合拼接
        List<String> address = Stream.concat(country.stream(), school.stream())
                .collect(toList());
        //打印结果
        System.out.println(address);
    }
}

3.1、逐一处理：forEash

注：
虽然操作以及名称，都和for很像，但是原理是不一样的。
一个是管道流，一个是遍历。

//方法1：逐一处理
 void test_forEach() {
        String[] array = {"河南省", "新乡市", "河南师范大学"};
        Stream<String> arrayStream = Stream.of(array);
        /**
         * parallel()函数表示对管道中的元素进行并行处理而不是串行处理。
         * 但是这样就有可能导致管道流中后面的元素先处理，前面的元素后处理，也就是元素的顺序无法保证。
         * 数据量大的话，就能观察到数据顺序是无法保证的.
         * 不想用，不用
         */
        arrayStream.parallel().forEach(item -> System.out.println(item));

        arrayStream.forEach(item -> {
            //在这个地方可以对每个item进行操作
            System.out.println(item);
        });
    }

在这里插入图片描述

3.2、过滤：filter

注：
可以通过 filter 方法，将一个流转换成另一个子集流

//方法2：过滤
void testFilter() {
    List<String> nameStrs = Arrays.asList("河南省", "新乡市", "河南师范大学");
    List<String> list = nameStrs.stream()
            .filter(s -> s.startsWith("河南"))
            //转换成了List的数据结构，方便接受和打印
            .collect(toList());
    System.out.println(list);
}

在这里插入图片描述

3.3、映射：map

注：
如果需要将流中的元素映射到另一个流中，可以使用 map 方法。

	//方法3：映射：map；将集合中的每一个字符串全部大写
    void test_map() {
        // Arrays.asList(),将数组转换为字符串
        List<String> players = Arrays.asList("Kobe Bean Bryant", "James", "Harden", "Curry", "Durant");
        List<String> list = players.stream()
                //s-> s.toUpperCase(),可以替换为String::toUpperCase(方法引用)
                .map(String::toUpperCase)
                // 转换成了List的数据结构，方便接收和打印
                .collect(toList());
        System.out.println(list);
    }

在这里插入图片描述

3.4、排序：sort

	//方法4：排序：sorted
    void test_sorted() {
        List<Integer> nums = Arrays.asList(2, 6, 5, 4, 8, 7, 9);
        //sorted，默认是升序
        List<Integer> list = nums.stream().sorted().collect(toList());
        System.out.println(list);
        //如果想要降序的话
        Collections.reverse(list);
        System.out.println(list);
    }

在这里插入图片描述

3.5、转换：collect

常用的，上面已经提及到了。

	//方法5：转换：collect
    void test_collect() {
        //list，set可以互转。
        //list转成map的话，index当做key，元素就当做value
        //具体，有时间再写
    }

3.6、统计个数：count

//方法6：统计个数：count
    void test_count() {
        List<String> nameStrs = Arrays.asList("河南省", "新乡市", "河南师范大学");
        long count = nameStrs.stream()
                .filter(s -> s.startsWith("河南"))
                .count();
        //打印个数
        System.out.println(count);
    }

在这里插入图片描述

3.7、截取：limit

	//方法7：测试截取：limit
    void test_limit(){
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> limit= school.stream()
        		// 截取前两个
                .limit(2)
                .collect(toList());
        //打印结果
        System.out.println(limit);
    }

在这里插入图片描述

3.8、跳跃：skip

	//方法8：跳过：skip
    void test_skip(){
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        List<String> skip = school.stream()
                //跳过前两个
                .skip(2)
                .collect(toList());
        //打印结果
        System.out.println(skip);
    }

在这里插入图片描述

3.9、组合拼接：concat

	//方法9：组合：concat
    void test_concat() {
        List<String> country = Arrays.asList("地球", "中华人民共和国");
        List<String> school = Arrays.asList("河南省", "新乡市", "河南师范大学");
        //将上面的两个集合拼接
        List<String> address = Stream.concat(country.stream(), school.stream())
        .collect(toList());
        //打印结果
        System.out.println(address);
    }

在这里插入图片描述

四、推荐链接

倜傥的雷哥：https://ke.qq.com/teacher/316518226 （腾讯课堂，讲的很好，推荐一波）
风骚的稽哥：https://ke.qq.com/teacher/1579106394 （腾讯课堂，风趣有味，知识渊博）

子 ★ 诚
发布了44 篇原创文章 · 获赞 5 · 访问量 886
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_40634246/article/details/105248150
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022