Stream流的中间方法、终结方法与收集方法-CSDN博客

本文链接：https://blog.csdn.net/Sexycake/article/details/148075747

Java Stream 流简介

Java Stream 是 Java 8 引入的一个强大的功能，用于处理集合（如 List、Set 等）中的数据。Stream 提供了一种高效、声明式的方式来对集合进行操作，例如过滤、排序、转换、聚合等。它类似于数据库中的 SQL 查询，允许你以一种更简洁和直观的方式来处理数据。

Stream 的核心概念

Stream：数据的序列，可以包含有限或无限个元素。
操作：对 Stream 中的数据进行的操作，如过滤、映射、排序等。
终端操作：产生结果的操作，如 collect、forEach、sum 等。终端操作会触发 Stream 的执行。
惰性求值：Stream 的操作是惰性求值的，只有在执行终端操作时，才会真正执行中间操作。

中间方法:

package Stream;

import java.util.*;
import java.util.Collections;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class demo1 {
    public static void main(String[] args) {
        //stream流只能使用一次
        //修改流中数据，不会影响源数据
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三", "张三","张三","李四","李四",  "王五", "赵六","张二2");
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list, "append");
        //filter过滤 留下张开头的
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                //true留下，false不要
                return s.startsWith("张");
            }
        }).forEach(s -> System.out.println(s));
        System.out.println("-------------");

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

        //还是原数据
        //System.out.println(list);
        //limit 获取前几个 skip跳过前几个
        list.stream().limit(2).forEach(s-> System.out.println(s));
        System.out.println("-------------");
        list.stream().skip(2).forEach(s-> System.out.println(s));
        System.out.println("-------------");
        //distinct去重，依赖hashcode与equals
        list.stream().distinct().forEach(s-> System.out.println(s));
        System.out.println("-------------");
        Stream.concat(list1.stream(),list.stream()).forEach(s-> System.out.println(s));

    }
}

转换流中数据

//stream流只能使用一次
        //修改流中数据，不会影响源数据
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三-10","李四-9",  "王五-8", "赵六-7","张二-2");
        //只获取年龄 string->int
        //第一个类型，原本数据类型，第二个类型，转换后数据类型
        //apply形参表示每个数据，返回转换后数据
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                String[] arr = s.split("-");
                String age1 = arr[1];
                int age = Integer.parseInt(age1);
                return age;
            }
        }).forEach(s-> System.out.println(s));

终结方法：

package Stream;

import java.util.*;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class demo1 {
    public static void main(String[] args) {
        //stream流只能使用一次
        //修改流中数据，不会影响源数据
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三-10","李四-9",  "王五-8", "赵六-7","张二-2");

        //void forEach(Consumer action)
        //Cosumer泛型：表示流中数据
        //方法体打印处理
//        list.stream().forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
        list.stream().forEach(s->System.out.println(s));

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

        //收集toArray
        Object[] arr1 = list.stream().toArray();
        System.out.println(Arrays.toString(arr1));

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




    }
}

收集方法:

package Stream;

import java.util.*;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class demo1 {
    public static void main(String[] args) {
        //collect(Collector collector) 收集流中数据
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三-男-10","李四-女-9",  "王五-男-8", "赵六-女-7","张二-男-2");
        //收集List集合
        //收集所有男性
        List<String> newList = list.stream().filter(s->"男".equals(s.split("-")[1]))
                .collect(Collectors.toList());
        System.out.println(newList);
        //收集set去重
        Set<String> newlist2 =
        list.stream().filter(s->"男".equals(s.split("-")[1]))
                .collect(Collectors.toSet());
        System.out.println(newlist2);
        //map 键值对确定
        //收集男性 键：名字 值：年龄
        //收集进Map，不可重复，否则报错
        /*
        to map ：参数一表示键的生成规则
                 参数二表示值的生成规则
         */
        //匿名内部类
        Map<String,Integer> map =
        list.stream().filter(s->"男".equals(s.split("-")[1]))
                .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]);

                    }
                }));
        //lambda表达式
        System.out.println(map);
        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);
    }
}