stream流-优快云博客

本文链接：https://blog.youkuaiyun.com/rwh19951022/article/details/129360182

文章介绍了Java中的StreamAPI，包括如何从集合、数组获取Stream，以及Stream的基本操作如forEach、count、limit、skip、filter、map等方法的使用。此外，还展示了如何将Stream收集到不同的集合以及检查集合中对象字段的重复情况。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

目的

为了简化对集合或者数组的操作

注意：

stream只是函数模型，一定要有终结方法（forEach或者count），否则是不会执行的

stream流不存储任何数据

stream流只能操作一次

stream流操作不会改变原来的数据

获取流


package com.nanwu;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Stream;

/**
 * 获取stream的方式
 *
 * 任王胡
 * 2023-03-06 13:29
 */
public class MyStream {
    public static void main(String[] args) {
        // 单列集合
        List<String> list=new ArrayList<>();
        Stream<String> stream = list.stream();

        Set<String> set=new HashSet<>();
        Stream<String> stream1 = set.stream();

        // 双列集合---先把双列变单列，再用单列的规则
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"haha");
        map.put(2,"hehe");
        map.put(3,"oo");
        Set<Integer> integerSet = map.keySet();
        Stream<Integer> stream2 = integerSet.stream();
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        Stream<Map.Entry<Integer, String>> stream3 = entries.stream();
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        // 数组
        int[] arr={1,2,3};
        Stream<int[]> stream5 = Stream.of(arr);
    }
}

流的常用方法


package com.nanwu;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

/**
 * stream流常用方法
 *
 * 任王胡
 * 2023-03-06 13:46
 */
public class MyStream1 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"卡萨丁");
        map.put(2,"德莱文");
        map.put(3,"卡特琳娜");
        map.put(4,"希瓦娜");
        map.put(5,"卡兹克");
        Collection<String> values = map.values();

        // forEach--逐一处理---终结方法
        values.stream().forEach(System.out::println);
        System.out.println("------");

        // count---统计个数---终结方法
        long count = values.stream().count();
        System.out.println(count);
        System.out.println("------");

        // limit---取前n个
        values.stream().limit(2).forEach(System.out::println);
        System.out.println("------");

        // skip---跳过前n个
        values.stream().skip(3).forEach(System.out::println);
        System.out.println("------");

        // filter---过滤
        values.stream().filter(s->s.length()>3).forEach(System.out::println);
        System.out.println("------");

        // concat---将两个流组合
        Stream<String> str = values.stream().limit(1);
        Stream<String> str1 = values.stream().filter(s -> s.startsWith("德"));
        Stream.concat(str,str1).forEach(System.out::println);
        System.out.println("------");

        // map---接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
        // 案例1：将所有“卡”字，变为“ka”
        values.stream().map(s -> s.replace("卡","ka")).forEach(System.out::println);
        System.out.println("------");

        // map----案例:2：将数组中的字母全部大写
        String[] arr={"abc","def","ree"};
        Stream.of(arr).map(s -> s.toUpperCase()).forEach(System.out::println);
        System.out.println("------");
    }
}

执行结果


卡萨丁
德莱文
卡特琳娜
希瓦娜
卡兹克
------
5
------
卡萨丁
德莱文
------
希瓦娜
卡兹克
------
卡特琳娜
------
卡萨丁
德莱文
------
ka萨丁
德莱文
ka特琳娜
希瓦娜
ka兹克
------
ABC
DEF
REE
------

Process finished with exit code 0

map方法注意：

流.map(s -> 对s的逻辑处理).forEach

将流收集到集合


package com.nanwu;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 将流收集到集合
 * <p>
 * 任王胡
 * 2023-03-06 14:23
 */
public class MyStream2 {
    public static void main(String[] args) {
        // 收集到单例集合
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "haha", "hehe", "aa", "bb");
        List<String> list1 = list.stream().filter(s -> s.length() == 2).collect(Collectors.toList());
        System.out.println(list1);
        System.out.println("---------");

        Set<String> list2 = list.stream().filter(s -> s.length() == 2).collect(Collectors.toSet());
        System.out.println(list2);
        System.out.println("---------");

        // 收集到双列集合
        List<String> list3=new ArrayList<>();
        list3.add("1北京");
        list3.add("2上海");
        list3.add("3广州");
        list3.add("4广州");
        Map<Integer, String> integerStringMap = list3.stream().limit(3).collect(Collectors.toMap
                (s -> Integer.valueOf(s.substring(0, 1)), s -> s.substring(1)));
        System.out.println(integerStringMap);
        System.out.println("---------");

        // 收集到数组
        Object[] objects = list.stream().limit(2).toArray();
        System.out.println(Arrays.toString(objects));
    }
}

执行结果


[aa, bb]
---------
{1=北京, 2=上海, 3=广州}
---------
[haha, hehe]

收集到双列集合图解

判断集合中对象某个字段是否重复

@Test
    public void test01() throws Exception {
        User user = new User();
        user.setAge(17);
        user.setUsername("jack");
        User user1 = new User();
        user1.setAge(18);
        user1.setUsername("rose");
        User user2 = new User();
        user2.setAge(19);
        user2.setUsername("tom");
        List<User> list = new ArrayList<>();
        Collections.addAll(list, user, user1, user2);

        // 判断age字段是否有重复
        Map<Integer, List<User>> map = list.stream().collect(Collectors.groupingBy(User::getAge));
        for (List<User> value : map.values()) {
            if (value.size() > 1) {
                throw new RuntimeException("年龄重复！");
            }
        }

        List<User> userList = list.stream().filter(user3 -> user3.getUsername() == null).collect(Collectors.toList());
        if (userList.size()>0) {
            throw new RuntimeException("姓名不能为空！");
        }

    }