JAVA Stream流（十四）

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量783 收藏 24
点赞数 25
分类专栏： JAVA 文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljs__123/article/details/135672789
版权

Stream流（十四）

获取Stream流

Stream流结合Lambda表达式，简化集合和数组的操作。
使用步骤：

  1. 先得到一条Stream流（流水线），并把数据放上去
  2. 利用Stream流中的API进行各种操作，操作包含：数据过滤，类型转换，数据统计，数据打印等
    • 过滤和转换是中间方法，方法调用完毕后，可调用其他方法
    • 统计和打印是终结方法，最后一步，调用完毕后，不可调用其他方法

获取方式：

  • 单列集合
    • 方法名：default Stream stream()
    • 说明：Collection中的默认方法
  • 双列集合
    • 不可直接获取，需通过keySet或entrySet获取单列集合后进行获取
  • 数组
    • 方法名：public static Stream stream(T[] array)
    • 说明：Arrays工具类的静态方法
  • 一堆零散数据
    • 方法名：public static Stream of(T…values)
    • 说明：Stream接口中的静态方法
    • 方法的形参是一个可变参数，可传递一堆零散的数据，也可传递数组，但传递数组必须是引用数据类型，若传递基本数据类型，会把整个数组当成一个元素放到Stream中

范例：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.stream.Stream;
public class Test{
    public static void main(String[] args){
        //单列集合
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"a","b","c","d","e");
        list.stream().forEach(s->System.out.print(s+" "));
        System.out.println();

        //双列集合
        //方式一：
        HashMap<String,Integer> hm=new HashMap<>();
        hm.put("a",97);
        hm.put("b",98);
        hm.put("c",99);
        hm.put("d",100);
        hm.put("e",101);
        //方式一：
        hm.keySet().stream().forEach(s-> System.out.print(s+"="+hm.get(s)+" "));
        System.out.println();
        hm.entrySet().stream().forEach(entry-> System.out.print(entry+" "));
        System.out.println();

        //数组
        String[] arr={"a","b","c","d","e"};
        Arrays.stream(arr).forEach(s-> System.out.print(s+" "));
        System.out.println();
        int[] arr1={1,2,3,4,5};
        Arrays.stream(arr1).forEach(i-> System.out.print(i+" "));
        System.out.println();

        //零散数据
        Stream.of(8,5,6,7,9).forEach(i -> System.out.print(i+" "));

    }
}
/*
a b c d e 
a=97 b=98 c=99 d=100 e=101 
a=97 b=98 c=99 d=100 e=101 
a b c d e 
1 2 3 4 5 
8 5 6 7 9 
*/

中间方法

中间方法返回的新Stream流，原本的Stream流只能使用一次，建议使用链式编程。

修改Stream流中的数据，不会影响原来集合或数组中的数据。

fiter

格式：

Stream filter(Predicate<? super T> predicate)

说明：过滤

limit

格式：

Stream limit(long maxSize)

说明：获取前面maxSize个元素

skip

格式：

Stream skip(long n)

说明：跳过前面n个元素

distinct

格式：

Stream distinct()

说明：元素去重，依赖（hashCode和equals方法）

concat

格式：

static Stream concat(Stream a,Stream b)

说明：合并a和b两个流为一个流，然后a和b流就不能使用了

map

格式：

Stream map(Function<T,R> mapper)

说明：转换流中的数据类型

范例
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"abc","acdb","bcd","cde","aaa","dfsf","afe");
        //filter方法
        //只留下a开头的
        System.out.println("filter方法");
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("a");
            }
        }).forEach(s-> System.out.print(s+" "));
        System.out.println();
        //lambda
        list.stream().filter(s->s.startsWith("a")).forEach(s-> System.out.print(s+" "));
        System.out.println();

        //limit方法
        //获取前3个元素
        System.out.println("limit方法");
        list.stream().limit(3).forEach(s-> System.out.print(s+" "));
        System.out.println();

        //skip方法
        //跳过前3个元素
        System.out.println("skip方法");
        list.stream().skip(3).forEach(s-> System.out.print(s+" "));
        System.out.println();

        //只打印"bcd","cde","aaa"
        //方法一
        list.stream().limit(5).skip(2).forEach(s-> System.out.print(s+" "));
        System.out.println();
        //方法二
        list.stream().skip(2).limit(3).forEach(s-> System.out.print(s+" "));
        System.out.println();

        //distinct
        System.out.println("distinct方法");
        ArrayList<String> list1=new ArrayList<>();
        Collections.addAll(list1,"aaa","ccc","aaa");
        list1.stream().distinct().forEach(s-> System.out.print(s+" "));
        System.out.println();

        //concat方法
        System.out.println("concat方法");
        Stream.concat(list.stream(),list1.stream()).forEach(s-> System.out.print(s+" "));
        System.out.println();

        //map方法
        System.out.println("map方法");
        ArrayList<String> list2=new ArrayList<>();
        Collections.addAll(list2,"a-1","b-2","ab-12");
        list2.stream().map(new Function<String, Integer>() {
        //第一个类型：流中原本的数据类型
        //第二个类型：要转换之后的类型
        //apply的形参s:依次表示流里面的每一个数据
        //返回值：表示转换之后的数据
        //当map方法执行完毕之后，流上的数据就变成了整数，所以下面的foreach中，s依次表示流里面的每一个数据，该数据的类型为整数
            @Override
            public Integer apply(String s) {
                String[] arr1=s.split("-");
                String str=arr1[1];
                return Integer.parseInt(str);
            }
        }).forEach(s-> System.out.print(s+" "));
        System.out.println();

        //lambda
        list2.stream().map(s-> Integer.parseInt(s.split("-")[1])).forEach(s-> System.out.print(s+" "));
    }
}
/*
filter方法
abc acdb aaa afe 
abc acdb aaa afe 
limit方法
abc acdb bcd 
skip方法
cde aaa dfsf afe 
bcd cde aaa 
bcd cde aaa 
distinct方法
aaa ccc 
concat方法
abc acdb bcd cde aaa dfsf afe aaa ccc aaa 
map方法
1 2 12 
1 2 12 
*/

终结方法

forEach

格式：

void forEach(Consumer action)

说明：遍历

count

格式：

long count()

说明：统计

toArray

格式1：

Object[] toArray()

说明：返回包含此流元素的数组。

格式2：

< A > A[] toArray(IntFunction<A[]> generator)

说明：返回指定类型的数组

collect

格式：

collect(Collector collector)

说明：收集流中的数据，放到集合中

  • Collectors.toList()，可以有重复
  • Collectors.toSet()，自动去重
  • Collectors.toMap()，键不可重复，否则会报错
范例
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.stream.Collectors;

public class Test{
    public static void main(String[] args){
        System.out.println("forEach方法");
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"aaa","bbb","ccc");
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print(s+" ");
            }
        });
        System.out.println();
        //lambda
        list.stream().forEach(s-> System.out.print(s+" "));
        System.out.println();

        System.out.println();
        System.out.println("count方法");
        long num=list.stream().count();
        System.out.println(num);
        System.out.println();

        System.out.println("toArray方法");
        //InFunction的泛型，具体类型的数组
        //apply的形参：流中的数据个数，要跟数组长度一致
        //apply的返回值，具体类型的数组
        //方法体：就是创建数组
        String[] str1=list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(Arrays.toString(str1));
        //lambda
        String[] str2=list.stream().toArray(value->new String[value]);
        System.out.println(Arrays.toString(str2));
        System.out.println();

        System.out.println("collect方法-Collectors.toList()");
        ArrayList<String> list1=new ArrayList<>();
        Collections.addAll(list1,"张三-河北省-18","张三-河北省-18","李四-河南省-19","王五-湖南省-18","路人甲-湖北省-20","路人乙-河北省-19","路人丙-河北省-21");
        List<String> newList=list1.stream().
                filter(s->"河北省".equals(s.split("-")[1])).
                collect(Collectors.toList());
        System.out.println(newList);
        System.out.println("collect方法-Collectors.toSet()");
        Set<String> newSet=list1.stream().
                filter(s->"河北省".equals(s.split("-")[1])).
                collect(Collectors.toSet());
        System.out.println(newSet);
        System.out.println("collect方法-Collectors.toMap()");
        ArrayList<String> list2=new ArrayList<>();
        Collections.addAll(list2,"张三-河北省-18","李四-河南省-19","王五-湖南省-18","路人甲-湖北省-20","路人乙-河北省-19","路人丙-河北省-21");
        Map<String,Integer> newMap=list2.stream().
                filter(s->"河北省".equals(s.split("-")[1])).
                /*
                toMap:  参数一表示键的生成规则
                        参数二表示值的生成规则
                参数一：
                        Function泛型一：表示流中每个数据的类型
                                泛型二：表示Map集合中键的数据类型

                        方法apply形参：依次表示流里面的每个数据
                               方法体：生成键的代码
                               返回值：已经生成的键
                参数二：
                        Function泛型一：表示流中每个数据的类型
                                泛型二：表示Map集合中值的数据类型

                        方法apply形参：依次表示流里面的每个数据
                               方法体：生成值的代码
                               返回值：已经生成的值
                */
                collect(Collectors.toMap(new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        return s.split("-")[0];
                    }
                    },
                        new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) {
                        return Integer.parseInt(s.split("-")[2]);
                    }}));
        System.out.println(newMap);
        //lambda
        Map<String,Integer> newMap1=list2.stream().
                filter(s->"河北省".equals(s.split("-")[1])).
                collect(Collectors.toMap(s-> s.split("-")[0],
                        s->Integer.parseInt(s.split("-")[2])));
        System.out.println(newMap1);
    }
}
/*
forEach方法
aaa bbb ccc 
aaa bbb ccc 

count方法
3

toArray方法
[aaa, bbb, ccc]
[aaa, bbb, ccc]

collect方法-Collectors.toList()
[张三-河北省-18, 张三-河北省-18, 路人乙-河北省-19, 路人丙-河北省-21]
collect方法-Collectors.toSet()
[路人丙-河北省-21, 张三-河北省-18, 路人乙-河北省-19]
collect方法-Collectors.toMap()
{路人丙=21, 路人乙=19, 张三=18}
{路人丙=21, 路人乙=19, 张三=18}

*/

范例

例1

/*
定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
过滤奇数，只剩下偶数
并将结果保存起来
*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class Test{
    public static void main(String[] args){
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
        List<Integer> newList = list.stream().filter(i->i%2==0).collect(Collectors.toList());
        System.out.println(newList);
    }
}
/*
[2, 4, 6, 8, 10]
*/

例2

/*
练习：
创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄
"zhangsan,23"
"lisi,24"
"wangwu,25"
保留年龄大于等于24的人，并将结果放入Map集合中，姓名为键，年龄为值
*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.stream.Collectors;

public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"zhangsan,23","lisi,24","wangwu,25");
        Map<String,Integer> map=list.stream().
                filter(s->Integer.parseInt(s.split(",")[1])>=24).
                collect(Collectors.toMap(s-> s.split(",")[0],
                        s->Integer.parseInt(s.split(",")[1])));
        System.out.println(map);
    }
}
/*
{lisi=24, wangwu=25}
*/

例3

/*
现有两个ArrayList集合，分别存储6名男演员的名字和年龄以及6名女演员的名字和年龄，
姓名和年龄中间用逗号隔开，
比如:张三，23
要求完成以下操作：
1.男演员只要名字为3个字的前两个人
2.女演员只要姓杨的，并且不要第一个
3.把过滤后男演员信息和女演员信息合并到一起
4.将上一步的演员信息转换成Actor对象
5.将所有的演员对象都保存到List集合中
演员类Actor,属性名：name,age
男演员:"张楚阳,24","叶沙比,23","刘不甜,22","吴签,24","谷甲,30","肖凉凉,27"
女演员:"蔡徐坤,24","杨以,36","高媛媛,43","张甜甜,31","刘失,35","杨扎进,33"
*/
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Test{
    public static void main(String[] args){
        ArrayList<String> boyList=new ArrayList<>();
        ArrayList<String> girlList=new ArrayList<>();
        Collections.addAll(boyList,"张楚阳,24","叶沙比,23","刘不甜,22","吴签,24","谷甲,30","肖凉凉,27");
        Collections.addAll(girlList,"蔡徐坤,24","杨以,36","高媛媛,43","张甜甜,31","刘失,35","杨扎进,33");
        Stream<String> boyStream=boyList.stream().
                filter(s->s.split(",")[0].length()==3).
                limit(2);
        Stream<String> girlStream=girlList.stream().
                filter(s->s.startsWith("杨")).
                skip(1);
        List<Actor> list=Stream.concat(boyStream,girlStream).
                map(s->new Actor(s.split(",")[0],Integer.parseInt(s.split(",")[1]))).
                collect(Collectors.toList());
        System.out.println(list);
    }
}
/*
[Actor{name = 张楚阳, age = 24}, Actor{name = 叶沙比, age = 23}, Actor{name = 杨扎进, age = 33}]
*/
ljs__123
关注
  • 25
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Stream流的详解
流楚丶格念的博客
07-18 2511
Stream作为Java8的一大亮点，它与java.io包里的InputStream和OutputStream是完全不同的概念。Java8中的Stream是对集合(Collection)对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作(aggregateoperation)，或者大批量数据操作(bulkdataoperation)。StreamAPI借助于同样新出现的Lambda表达式，而且使用并发模式，极大的提高编程效率和程序可读性。...
JAVA-Stream流详解
分享，学习，专注，努力，向上。
07-02 3178
Stream（流）是Java 8引入的新特性，它是一种处理集合数据的高级抽象概念。Stream流提供了一种更为简洁、强大和易于使用的方式来操作数据集合，可以进行过滤、映射、排序、聚合等各种操作，同时还支持并行处理，提高了代码的可读性和性能。
Java Stream流详解
唯有努力，方可自信！
06-10 2万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 7万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
Java Stream流（详解）
m0_60489526的博客
08-29 7万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
Java - Stream流详解
weixin_73869209的博客
06-05 1万+
Stream流是Java 8中的一个新特性，它提供了一种处理集合和数组的方式。Stream流可以让我们以一种更加简洁、高效、可读性更强的方式来处理数据。Stream流可以用于过滤、映射、排序、聚合等操作，它可以让我们避免使用循环和条件语句来处理数据，从而让代码更加简洁易懂。Stream流的操作可以分为中间操作和终止操作两种类型，中间操作返回的是一个新的Stream流，终止操作返回的是一个非Stream类型的结果。Stream流的处理是惰性求值的，只有在执行终止操作时才会开始处理数据。
Java Stream流之求和
少年一贯快马扬帆，道阻且长不转弯； 要盛大，要绚烂，要哗然； 要用理想的泰坦尼克，去撞现实的冰川； 要当烧赤壁的风，而非借鉴草船； 要为了一片海，就肯翻万山。
04-14 2万+
Java Stream流之求和 流方式实现 基本数据类型 和 包装类型 的一位数组求和 package top.yangbocsu; import java.util.Arrays; /** * @author yangbocsu * @date 2022年4月14日 * @version 1.0 * @description: 流方式实现 基本数据类型 和 包装类型 的一位数组求和 */ public class Test { public static void main(St
java stream流排序_java stream流 排序
weixin_34785304的博客
02-28 1579
// 按状态排序，排序顺序是PipelineState枚举类的顺序List newPipelineList = pipelineList.stream().sorted(Comparator.comparing(Pipeline::getState)).collect(Collectors.toList());Collections.reverse(newPipelineList); //排序翻转...
Java8 Stream 流
weixin_44061521的博客
12-24 2570
简介 Java8两大新特征，一是支持 lambda 表达式，二是 Stream API。在使用 Stream API 之前，最好有 lambda表达式的基础，如果不太清楚，可以看我的另一篇博客lambda表达式。 在编写代码的过程中，我们经常要对集合或数组数据进行操作，而有了 Stream API，我们能够非常轻松的对集合、数据进行映射、过滤、查找等操作，使得我们能够像操作数据库一样的操作集合。 Stream 本身并不存储元素，它并不改变源数据，每次操作都会形成一个新的流，并且只有执行了Stream的终止操
Java中的Stream流详解
DJL新时代农民工DJL
03-29 5502
JDK8 Stream详解 概念 Stream是Java8 API的新成员，它允许以声明性方式处理数据集合 。 特点 （1）代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。 （2）多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。 流程 1）第一步：把集合转换为流stream 2）第二步：操作stream流 stream流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(term
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
Java Stream 流的使用过程解析
08-25
Java Stream 流的使用过程解析 Java Stream 流是 Java 8 中引入的一种新的数据处理方式，旨在提供一种高效、灵活的数据处理方法。Stream 流提供了丰富的数据处理功能，可以对数据进行筛选、映射、聚合、分组等操作...
JavaStream流
08-22
Java Stream流 详细文档
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 406
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 773
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java Stream流与方法引用解析
Stream流不是传统的I/O流，而是用来处理集合或者其他数据源的一种抽象概念，它支持一系列的中间操作和最终操作，形成一个数据处理的流水线。在Stream API中，Lambda表达式扮演了关键角色，使得代码更专注于解决问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值