首页 > 其他分享 >Stream 流

Stream 流

时间:2024-09-27 22:34:00浏览次数:11  
标签:Stream stream list System println out

程序示例:

import java.util.ArrayList;

public class StreamDemo1 {
    public static void main(String[] args) {
        /*
            创建集合添加元素,完成以下需求:
            1.把所有以“张”开头的元素存储到新集合中
            2.把“张”开头的,长度为3的元素再存储到新集合中
            3.遍历打印最终结果
        */
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("张无忌");
        list1.add("周芷若");
        list1.add("赵敏");
        list1.add("张强");
        list1.add("张三丰");

        list1.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));
        
        /*  
        // 1.把所有以“张”开头的元素存储到新集合中
        ArrayList<String> list2 = new ArrayList<>();
        for (String name : list1) {
            if(name.startsWith("张")){
                list2.add(name);
            }
        }
        // 2.把“张”开头的,长度为3的元素再存储到新集合中
        ArrayList<String> list3 = new ArrayList<>();
        for (String name : list2) {
            if(name.length() == 3){
                list3.add(name);
            }
        }

        // 3.遍历打印最终结果
        for (String name : list3) {
            System.out.println(name);
        }
        */
    }
}

Stream 流的作用: 结合了 Lambda 表达式, 简化集合、数组的操作.

Stream 流的使用步骤:

  1. 先得到一条 Stream 流 (流水线), 并把数据放上去.

  2. 利用 Stream 流中的 API 进行各种操作.

Stream 流的使用步骤:

  1. 先得到一条 Stream 流 (流水线), 并把数据放上去

  2. 使用中间方法对流水线上的数据进行操作

  3. 使用终结方法对流水线上的数据进行操作

程序示例:

import java.util.ArrayList;
import java.util.Collections;

public class StreamDemo2 {
    public static void main(String[] args) {
/*
        单列集合      default Stream<E> stream()                           Collection中的默认方法
        双列集合      无                                                   无法直接使用stream流
        数组          public static <T> Stream<T> stream(T[] array)        Arrays工具类中的静态方法
        一堆零散数据   public static<T> Stream<T> of(T... values)           Stream接口中的静态方法
*/
        //1.单列集合获取Stream流
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c","d","e");
        /*//获取到一条流水线,并把集合中的数据放到流水线上
        Stream<String> stream1 = list.stream();
        //使用终结方法打印一下流水线上的所有数据
        stream1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                //s:依次表示流水线上的每一个数据
                System.out.println(s);
            }
        });*/
        list.stream().forEach(s -> System.out.println(s));
    }
}

程序示例:

import java.util.HashMap;

public class StreamDemo3 {
    public static void main(String[] args) {
        // 双列集合      无                                                   无法直接使用stream流

        // 1.创建双列集合
        HashMap<String, Integer> hm = new HashMap<>();
        // 2.添加数据
        hm.put("aaa", 111);
        hm.put("bbb", 222);
        hm.put("ccc", 333);
        hm.put("ddd", 444);

        // 3.第一种获取stream流
        // hm.keySet().stream().forEach(s -> System.out.println(s));

        // 4.第二种获取stream流
        hm.entrySet().stream().forEach(s -> System.out.println(s));
    }
}

程序示例:

import java.util.stream.Stream;

public class StreamDemo4 {
    public static void main(String[] args) {
        // 数组          public static <T> Stream<T> stream(T[] array)        Arrays工具类中的静态方法

        // 1.创建数组
        int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        String[] arr2 = {"a", "b", "c"};

        // 2.获取stream流
        // Arrays.stream(arr1).forEach(s-> System.out.println(s));

        // System.out.println("============================");

        // Arrays.stream(arr2).forEach(s-> System.out.println(s));

        // System.out.println("============================");

        // 注意:
        // Stream接口中静态方法of的细节
        // 方法的形参是一个可变参数,可以传递一堆零散的数据,也可以传递数组
        // 但是数组必须是引用数据类型的,如果传递基本数据类型,是会把整个数组当做一个元素,放到Stream当中。
        Stream.of(arr1).forEach(s -> System.out.println(s));//[I@41629346

    }
}

程序示例:

import java.util.stream.Stream;

public class StreamDemo5 {
    public static void main(String[] args) {
        // 一堆零散数据   public static<T> Stream<T> of(T... values)           Stream接口中的静态方法

        Stream.of(1, 2, 3, 4, 5).forEach(s -> System.out.println(s));
        Stream.of("a", "b", "c", "d", "e").forEach(s -> System.out.println(s));
    }
}

Stream 流的中间方法:

注意 1: 中间方法, 返回新的 Stream 流, 原来的 Stream流 只能使用一次, 建议使用链式编程.

注意 2: 修改 Stream 流中的数据, 不会影响原来集合或者数数组中的数据.

程序示例:

import java.util.ArrayList;
import java.util.Collections;

public class StreamDemo6 {
    public static void main(String[] args) {
        /*
            filter              过滤
            limit               获取前几个元素
            skip                跳过前几个元素

            注意1:中间方法,返回新的Stream流,原来的Stream流只能使用一次,建议使用链式编程
            注意2:修改Stream流中的数据,不会影响原来集合或者数组中的数据
        */

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

        // filter   过滤  把张开头的留下,其余数据过滤不要
        /*list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                //如果返回值为true,表示当前数据留下
                //如果返回值为false,表示当前数据舍弃不要
                return s.startsWith("张");
            }
        }).forEach(s -> System.out.println(s));

        list.stream()
                .filter(s -> s.startsWith("张"))
                .filter(s -> s.length() == 3)
                .forEach(s -> System.out.println(s));

        System.out.println("====================================");
        System.out.println(list);*/
        
       /* limit               获取前几个元素
        skip                跳过前几个元素*/

        //"张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤"
        // list.stream().limit(3).forEach(s -> System.out.println(s));
        // list.stream().skip(4) .forEach(s -> System.out.println(s));

        // 课堂练习:
        //"张强", "张三丰", "张翠山"
        // 第一种思路:
        // 先获取前面6个元素:"张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山",
        // 然后跳过前面3个元素
        // list.stream().limit(6).skip(3).forEach(s -> System.out.println(s));

        // 第二种思路:
        // 先跳过3个元素:"张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤"
        // 然后再获取前面3个元素:"张强", "张三丰", "张翠山"
        // list.stream().skip(3).limit(3).forEach(s -> System.out.println(s));
    }
}

程序示例:

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class StreamDemo8 {
    public static void main(String[] args) {
         /*
            map                 转换流中的数据类型

            注意1:中间方法,返回新的Stream流,原来的Stream流只能使用一次,建议使用链式编程
            注意2:修改Stream流中的数据,不会影响原来集合或者数组中的数据
        */

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠山-40", "张良-35", "王二麻子-37", "谢广坤-41");
        // 需求:只获取里面的年龄并进行打印
        // String->int

        // 第一个类型:流中原本的数据类型
        // 第二个类型:要转成之后的类型

        // apply的形参s:依次表示流里面的每一个数据
        // 返回值:表示转换之后的数据

        // 当map方法执行完毕之后,流上的数据就变成了整数
        // 所以在下面forEach当中,s依次表示流里面的每一个数据,这个数据现在就是整数了
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                String[] arr = s.split("-");
                String ageString = arr[1];
                int age = Integer.parseInt(ageString);
                return age;
            }
        }).forEach(s -> System.out.println(s));

        System.out.println("------------------------");
        
        list.stream()
                .map(s -> Integer.parseInt(s.split("-")[1]))
                .forEach(s -> System.out.println(s));
    }
}

Stream 流的终结方法:

程序示例:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class StreamDemo9 {
    public static void main(String[] args) {
       /*
            void forEach(Consumer action)           遍历
            long count()                            统计
            toArray()                               收集流中的数据,放到数组中
       */

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

        // void forEach(Consumer action)           遍历

        // Consumer的泛型:表示流中数据的类型
        // accept方法的形参s:依次表示流里面的每一个数据
        // 方法体:对每一个数据的处理操作(打印)
        /*list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        // list.stream().forEach(s -> System.out.println(s));

        // long count()                            统计
        // long count = list.stream().count();
        // System.out.println(count);

        // toArray()                               收集流中的数据,放到数组中
        // Object[] arr1 = list.stream().toArray();
        // System.out.println(Arrays.toString(arr1));

        // IntFunction的泛型:具体类型的数组
        // apply的形参:流中数据的个数,要跟数组的长度保持一致
        // apply的返回值:具体类型的数组
        // 方法体:就是创建数组


        // toArray方法的参数的作用:负责创建一个指定类型的数组
        // toArray方法的底层,会依次得到流里面的每一个数据,并把数据放到数组当中
        // toArray方法的返回值:是一个装着流里面所有数据的数组
        /* String[] arr = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });

        System.out.println(Arrays.toString(arr));
        */

        String[] arr2 = list.stream().toArray(value -> new String[value]);
        System.out.println(Arrays.toString(arr2));
    }
}

程序示例:

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class StreamDemo10 {
    public static void main(String[] args) {

        /*
            collect(Collector collector)            收集流中的数据,放到集合中 (List Set Map)

            注意点:
                如果我们要收集到Map集合当中,键不能重复,否则会报错
       */

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
                "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");

        // 收集List集合当中
        // 需求:
        // 我要把所有的男性收集起来
        List<String> newList1 = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toList());
        // System.out.println(newList1);


        // 收集Set集合当中
        // 需求:
        // 我要把所有的男性收集起来
        Set<String> newList2 = list.stream().filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toSet());
        // System.out.println(newList2);

        // 收集Map集合当中
        // 谁作为键,谁作为值.
        // 我要把所有的男性收集起来
        // 键:姓名。 值:年龄
        Map<String, Integer> map = list.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) {
                                                  // 张无忌-男-15
                                                  return s.split("-")[0];
                                              }
                                          },
                        new Function<String, Integer>() {
                            @Override
                            public Integer apply(String s) {
                                return Integer.parseInt(s.split("-")[2]);
                            }
                        }));

        Map<String, Integer> map2 = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toMap(
                        s -> s.split("-")[0],
                        s -> Integer.parseInt(s.split("-")[2])));

        System.out.println(map2);
    }
}

标签:Stream,stream,list,System,println,out
From: https://www.cnblogs.com/Chengkai730/p/18436628

相关文章

  • Stream流学习
    使用步骤:1.创建Stream流Stream流可以通过多种方式创建,主要包括以下几种:通过集合(Collection):使用Collection接口中的stream()方法获取顺序流,如List<String>list=newArrayList<>();Stream<String>stream=list.stream();使用Collection接口中的parallelStream()......
  • Flink(五)DataStream流处理算子
    DataStream流处理算子Source算子(数据读入)Flink可以使用StreamExecutionEnvironment.addSource(source)来为我们的程序添加数据来源基于本地集合的sourceDataStream<String>words=env.fromElements("hello","flink","stream");基于文件的sourcereadTextFile(path)......
  • 基于SpringBoot 应用Stream流+递归 实现多级分类
    SpringBoot->Stream流实现步骤:先查询所有级联的数据,然后通过Java8 Stream 流来比较和判断,最终生成有顺序的级联数据实体类:@DatapublicclassAddr{/***主键id*/privateLongaddrId;/***名称*/privateStringaddrNam......
  • stream
    注:List.of()方法需要1.8以上才支持1.filter,过滤,关键:PredicateStream.of(newFruit("草莓","","1","red"),newFruit("香蕉","","2","yellow"......
  • StreamInTest
    packagecom.shrimpking.t1;importjava.io.BufferedReader;importjava.io.InputStreamReader;/***CreatedbyIntelliJIDEA.**@Author:Shrimpking*@create2024/9/1410:45*/publicclassStreamInTest{publicstaticvoidmain(String[]args)......
  • Stream管理事件流
    文章目录概念介绍管理方法示例代码我们在上一章回中介绍了事件流相关的内容,本章回中将介绍如何管理Stream事件流。闲话休提,言归正传,让我们一起TalkFlutter吧。概念介绍我们简单回顾一下前面的知识:Stream把相关的事件组成了事件流,并且提供方法来监听这些事件的运......
  • `std::string_view`(c++17) 和 `std::stringstream` 使用区别·
    std::string_view和std::stringstream都是C++中处理字符串的工具,但它们的设计目标和使用场景非常不同。我们可以通过几方面进行对比。1.设计目的和核心功能std::string_view:设计用于只读访问字符串或字符序列。是一个轻量级的字符串视图,不会持有字符串的数据,仅仅是对......
  • faststream 自己的asgi 实现
    faststream目前自己包含了一个asgi的实现,可以快速实现api能力,同时也可以与其他web框架集成,以下是一个简单试用参考代码demo.pyfromfaststream.redisimportRedisBrokerfromfaststream.asgiimportAsgiFastStream,get,AsgiResponsefromtypingimportAnyfrompyda......
  • 为什么 Streams API 改变了 Web 开发者的游戏规则
    我们首先解释一下数据是如何通过网络发送的。它不是作为单个连续流发送的;相反,它被分成更小的块。在接收端,消费者或应用程序负责在收到所有数据后以正确的顺序和格式重新组装这些块。对于图像、视频和其他相对较大的数据类型,此过程会自动发生。因此streamsapi提供的是一种无需等......
  • Java Stream流编程入门
    流式编程stream流式编程分为首先转化为stream中间函数的链接最后的终结函数怎么转化为stream单列集合List<String>list=newArrayList<String>();Collections.addAll(list,"1","2","3","4","5","6","7","8"......