投稿
  1. 首页
  2. 随笔

Java Stream流

冰淇淋自动售卖机 • 2022-12-16 • 随笔 • 阅读 22

Java Stream流,第1张

Java Stream流

目录
  • 1.Stream 流的获取方法
  • 2.Stream 流的常见中间方法
  • 3.Stream 流的常见终结方法
  • 4.Stream 流的收集方法

获取 Stream 流：创建一条流水线，并把数据放到流水线上准备进行 *** 作。

中间方法：流水线上的 *** 作。一次 *** 作完毕之后，还可以继续进行其他 *** 作。

终结方法：一个 Stream 流只能有一个终结方法，是流水线上的最后一个 *** 作。

示例：创建一个集合，存储多个字符串元素 “张三丰”, “张无忌”, “张翠山”, “王二麻子”, “张良”, “谢广坤”，把集合中所有以 “张” 开头的元素存储到一个新的集合，再把 “张” 开头的集合中的长度为 3 的元素存储到一个新的集合并遍历。

package com.qdu.streamdemo;

import java.util.ArrayList;
import java.util.List;

public class MyStream1 {
    public static void main(String[] args) {
        // 集合的批量添加
        ArrayList list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));

        // 遍历list1把以"张"开头的元素添加到list2中
        ArrayList list2 = new ArrayList<>();
        for (String s : list1) {
            if(s.startsWith("张")) {
                list2.add(s);
            }
        }

        // 遍历list2集合，把其中长度为3的元素添加到list3中
        ArrayList list3 = new ArrayList<>();
        for (String s : list2) {
            if(s.length() == 3) {
                list3.add(s);
            }
        }

        for (String s : list3) {
            System.out.println(s);
        }

        System.out.println("------------------------------");

        // Stream流
        list1.stream().filter(s->s.startsWith("张"))
                .filter(s->s.length() == 3)
                .forEach(s-> System.out.println(s));
    }
}
1.Stream 流的获取方法

(1) 单列集合：可以使用 Collection 接口中的默认方法 default Stream stream() 生成流。

package com.qdu.streamdemo;

import java.util.ArrayList;

public class MyStream2 {
    public static void main(String[] args) {
        // 单列集合
        ArrayList list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

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

(2) 双列集合：间接地生成流。可以先通过 keySet 或者 entrySet 获取一个 Set 集合，再获取 Stream 流。

package com.qdu.streamdemo;

import java.util.HashMap;

public class MyStream2 {
    public static void main(String[] args) {
        // 双列集合
        HashMap hm = new HashMap<>();
        hm.put("zhangsan",23);
        hm.put("lisi",24);
        hm.put("wangwu",25);
        hm.put("zhaoliu",26);
        hm.put("qianqi",27);

        // 双列集合不能直接获取Stream流
        // keySet先获取到所有的键，再把这个Set集合中所有的键放到Stream流中
        hm.keySet().stream().forEach(s-> System.out.println(s));

        // entrySet先获取到所有的键值对对象，再把这个Set集合中所有的键值对对象放到Stream流中
        hm.entrySet().stream().forEach(s-> System.out.println(s));
    }
}

(3) 数组：Arrays 中的静态方法 stream() 生成流。

package com.qdu.streamdemo;

import java.util.Arrays;

public class MyStream2 {
    public static void main(String[] args) {
        int [] arr = {1, 2, 3, 4, 5};
        Arrays.stream(arr).forEach(s-> System.out.println(s));
    }
}

(4) 同种数据类型的多个数据：使用 Stream.of(T…values) 生成流

package com.qdu.streamdemo;

import java.util.stream.Stream;

public class MyStream2 {
    public static void main(String[] args) {
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8).forEach(s-> System.out.println(s));
    }
}
2.Stream 流的常见中间方法

(1) Stream filter(Predicate predicate)：用于对流中的数据进行过滤。

Predicate 接口中的方法 boolean test​(T t)：对给定的参数进行判断，返回一个布尔值。

package com.qdu.streamdemo;

import java.util.ArrayList;
import java.util.function.Predicate;

public class MyStream3 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        // test方法中的s依次表示流中的每一个数据，
        // 我们只要在test方法中对s进行判断就可以了，
        // 如果判断的结果为true，则当前的数据留下，
        // 如果判断的结果为false，则当前数据就不要。
        list.stream().filter(
                new Predicate() {
                    @Override
                    public boolean test(String s) {
                        boolean result = s.startsWith("张");
                        return result;
                    }
                }
        ).forEach(s-> System.out.println(s));

        System.out.println("---------------------------");

        // 因为Predicate接口中只有一个抽象方法test，所以我们可以使用lambda表达式来简化
        list.stream().filter(
                (String s) -> {
                    boolean result = s.startsWith("张");
                    return result;
                }
        ).forEach(s-> System.out.println(s));

        System.out.println("---------------------------");

        // lambda表达式还可以继续简化
        list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
    }
}

(2) Stream limit​(long maxSize)：截取指定参数个数的数据。

package com.qdu.streamdemo;

import java.util.ArrayList;

public class MyStream4 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        // Stream limit(long maxSize)：截取指定参数个数的数据
        list.stream().limit(2).forEach(s-> System.out.println(s));
    }
}

(3) Stream skip(long n)：跳过指定参数个数的数据。

package com.qdu.streamdemo;

import java.util.ArrayList;

public class MyStream4 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        // Stream skip(long n)：跳过指定参数个数的数据
        list.stream().skip(2).forEach(s-> System.out.println(s));
    }
}

(4) static Stream concat(Stream a, Stream b)：合并a和b两个流为一个流。

package com.qdu.streamdemo;

import java.util.ArrayList;
import java.util.stream.Stream;

public class MyStream4 {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList<>();
        list1.add("张三丰");
        list1.add("张无忌");
        list1.add("张翠山");

        ArrayList list2 = new ArrayList<>();
        list2.add("王二麻子");
        list2.add("张良");
        list2.add("谢广坤");

        // Stream stream1 = list1.stream();
        // Stream stream2 = list2.stream();
        // Stream stream3 = Stream.concat(stream1, stream2);
        // stream3.forEach(s-> System.out.println(s));

        // static  Stream concat(Stream a, Stream b)：合并a和b两个流为一个流
        Stream.concat(list1.stream(), list2.stream()).forEach(s -> System.out.println(s));
    }
}

(5) Stream distinct()：去除流中重复的元素。依赖hashCode和equals方法。

package com.qdu.streamdemo;

import java.util.ArrayList;

public class MyStream4 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        list.add("谢广坤");
        list.add("谢广坤");
        list.add("谢广坤");
        list.add("谢广坤");

        // Stream distinct()：去除流中重复的元素。依赖hashCode和equals方法。
        list.stream().distinct().forEach(s -> System.out.println(s));
    }
}
3.Stream 流的常见终结方法

(1) void forEach​(Consumer action)：对此流的每个元素执行 *** 作。

Consumer 接口中的方法 void accept​(T t)：对给定的参数执行此 *** 作。

package com.qdu.streamdemo;

import java.util.ArrayList;
import java.util.function.Consumer;

public class MyStream5 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        list.stream().forEach(
                new Consumer() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );

        System.out.println("-------------------------");

        // 因为Consumer接口中只有一个方法accept，所以可以使用lambda表达式进行简化
        list.stream().forEach(
                (String s) -> {
                    System.out.println(s);
                }
        );

        System.out.println("-------------------------");

        // lambda表达式还可以进一步简化
        list.stream().forEach(s->System.out.println(s));
    }
}

(2) long count()：返回此流中的元素数。

package com.qdu.streamdemo;

import java.util.ArrayList;

public class MyStream5 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        // long count()：返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
    }
}

示例：定义一个集合，并添加一些整数 1, 2, 3, 4, 5, 6, 7, 8, 9, 10，将集合中的奇数删除，只保留偶数。

package com.qdu.streamdemo;

import java.util.ArrayList;

public class MyStream6 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }

        list.stream().filter(number -> number % 2 == 0).forEach(number -> System.out.println(number));

        System.out.println("----------------------");

        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

结论：在 Stream 流中无法直接修改集合、数组等数据源中的数据。

4.Stream 流的收集方法

使用 Stream 流 *** 作完毕之后，怎么把流中的数据收集起来呢？

R collect(Collector collector)

工具类 Collectors 提供了具体的收集方式

  • public static Collector toList()：把元素收集到 List 集合中
  • public static Collector toSet()：把元素收集到 Set 集合中
  • public static Collector toMap(Function keyMapper, Function valueMapper)：把元素收集到 Map 集合中
package com.qdu.streamdemo;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class MyStream7 {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list1.add(i);
        }
        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);

        List list = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toList());

        System.out.println(list); // [2, 4, 6, 8, 10, 10, 10, 10, 10, 10]

        Set set = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toSet());

        System.out.println(set); // [2, 4, 6, 8, 10]
    }
}

package com.qdu.streamdemo;

import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;

public class MyStream8 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("lisi,24");
        list.add("wangwu,25");

        list.stream().filter(
                s -> {
                    String[] split = s.split(",");
                    int age = Integer.parseInt(split[1]);
                    return age >= 24;
                }
        ).forEach(s -> System.out.println(s));

        Map map = list.stream().filter(
                s -> {
                    String[] split = s.split(",");
                    int age = Integer.parseInt(split[1]);
                    return age >= 24;
                }
        ).collect(Collectors.toMap(
                s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1]) ));

        System.out.println(map);
    }
}

示例：现在有两个 ArrayList 集合，分别存储 6 名男演员名称和 6 名女演员名称，男演员只要名字为 3 个字的前两人，女演员只要姓杨的并且不要第一个，把过滤后的男演员姓名和女演员姓名合并到一起，作为构造方法的参数创建演员对象并遍历。

package com.qdu.streamdemo;

public class Actor {
    private String name;

    public Actor() {
    }

    public Actor(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Actor{" +
                "name='" + name + ''' +
                '}';
    }
}

package com.qdu.streamdemo;

import java.util.ArrayList;
import java.util.stream.Stream;

public class MyStream9 {
    public static void main(String[] args) {
        ArrayList  manList = new ArrayList<>();
        manList.add("张国立");
        manList.add("张晋");
        manList.add("刘烨");
        manList.add("郑伊健");
        manList.add("徐峥");
        manList.add("王宝强");

        ArrayList  womanList = new ArrayList<>();
        womanList.add("郑爽");
        womanList.add("杨紫");
        womanList.add("关晓彤");
        womanList.add("张天爱");
        womanList.add("杨幂");
        womanList.add("赵丽颖");

        // 男演员只要名字为3个字的前两人
        Stream stream1 = manList.stream().filter(name -> name.length() == 3).limit(2);

        //女演员只要姓杨的，并且不要第一个
        Stream stream2 = womanList.stream().filter(name -> name.startsWith("杨")).skip(1);

        // 把过滤后的男演员姓名和女演员姓名合并到一起，作为构造方法的参数创建演员对象并遍历
        Stream.concat(stream1, stream2).forEach(name -> {
            Actor actor = new Actor(name);
            System.out.println(actor);
        });
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5637114.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
冰淇淋自动售卖机 冰淇淋自动售卖机 一级用户组
0 0
上一篇 2022-12-16
下一篇 2022-12-16

发表评论

登录后才能评论

评论列表（0条）

保存