JavaStream流的使用

JavaStream流的使用

目录

• JavaStream流的使用
• 1、创建集合添加元素，完成以下需求
• 2、尝试Stream流
• 3、双列集合
• 4、数组
• 5、零散数据
• 6、filter，limit，skip的用法
• 7、去重，连接
• [8、map 转换流中的数据类型](#8、map 转换流中的数据类型)
• 9、遍历，统计，收集流中的数据，放到数组中
• [10、Collect(Collector collector) 收集流中的数据，放到集合中（List Set Map）](#10、Collect(Collector collector) 收集流中的数据，放到集合中（List Set Map）)
• 11、实战小练习

1、创建集合添加元素，完成以下需求

​ 1.把所有以"张"开头的元素存储到新集合中

​ 2.把"张"开头的，长度为3的元素再存储到新集合中

​ 3.遍历打印最终结果

package com.zjzakia01mystream;

import java.util.ArrayList;

/**
 * @author zjzaki
 * @create 2023年05月27日 22:20:35
 */
public class StreamDemo01 {

    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));

        //ArrayList<String> list1 = new ArrayList<>();
        //list1.add("张无忌");
        //list1.add("周芷若");
        //list1.add("赵敏");
        //list1.add("张强");
        //list1.add("张三丰");
        //
        1.把所有以"张"开头的元素存储到新集合中
        //ArrayList<String> list2 = new ArrayList<>();
        //for (String name : list1) {
        //    if (name.startsWith("张")) {
        //        list2.add(name);
        //    }
        //}
        //System.out.println(list2);
        //
         2.把"张"开头的，长度为3的元素再存储到新集合中
        //ArrayList<String> list3 = new ArrayList<>();
        //for (String name : list2) {
        //    if (name.length() == 3) {
        //        list3.add(name);
        //    }
        //}
        //System.out.println(list3);
        //
        3.遍历打印最终结果
        //for (String name : list3) {
        //    System.out.println(name);
        //}
    }
}

2、尝试Stream流

package com.zjzakia01mystream;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;

/**
 * @author zjzaki
 * @create 2023年05月27日 22:50:23
 */
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.单列集合
        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));
    }
}

3、双列集合

package com.zjzakia01mystream;

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

/**
 * @author zjzaki
 * @create 2023年05月27日 22:50:23
 */
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));
    }
}

4、数组

package com.zjzakia01mystream;

import java.util.Arrays;
import java.util.HashMap;

/**
 * @author zjzaki
 * @create 2023年05月27日 22:50:23
 */
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));
    }
}

5、零散数据

package com.zjzakia01mystream;

import java.util.Arrays;
import java.util.stream.Stream;

/**
 * @author zjzaki
 * @create 2023年05月27日 22:50:23
 */
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, 6).forEach(s -> System.out.println(s));
        Stream.of("a","b","c","d").forEach(s -> System.out.println(s));
    }
}

6、filter，limit，skip的用法

package com.zjzakia01mystream;

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

/**
 * @author zjzaki
 * @create 2023年05月28日 10:45:28
 */
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,表示留下
        //        return s.startsWith("张");
        //    }
        //}).forEach(s-> System.out.println(s));

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

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

        list.stream().skip(4).forEach(s-> System.out.println(s));
    }
}

7、去重，连接

package com.zjzakia01mystream;

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

/**
 * @author zjzaki
 * @create 2023年05月28日 10:45:28
 */
public class StreamDemo7 {

    public static void main(String[] args) {
        /*
            filter 过滤
            limit 获取前几个元素
            skip 跳过前几个元素
            注意1：中间方法，返回新的Stream，原来的Stream流只能使用一次，建议使用链式编程
            注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
         */
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1, "张无忌", "张无忌", "张无忌", "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");

        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "周芷若", "赵敏");
        //list1.stream().distinct().forEach(s-> System.out.println(s));
        Stream.concat(list1.stream(), list2.stream()).forEach(s -> System.out.println(s));
    }
}

8、map 转换流中的数据类型

package com.zjzakia01mystream;

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

/**
 * @author zjzaki
 * @create 2023年05月28日 10:45:28
 */
public class StreamDemo8 {

    public static void main(String[] args) {
        /*
           map 转换流中的数据类型
         */
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠三-40", "张良-35", "王二麻子-37");

        //只获取里面的年龄并进行打印
        //String -> int

        //第一个类型表示流中原本的类型，第二个表示转后的类型
        // apply 依次表示流里面的每一个数据
        //返回值：表示转换后的数据
        //list.stream().map(new Function<String, Integer>() {
        //
        //    @Override
        //    public Integer apply(String s) {
        //        String[] arr = s.split("-");
        //        String ageStr = arr[1];
        //        int age = Integer.parseInt(ageStr);
        //
        //        return age;
        //    }
        //}).forEach(s -> System.out.println(s));

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

9、遍历，统计，收集流中的数据，放到数组中

package com.zjzakia01mystream;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.IntFunction;

/**
 * @author zjzaki
 * @create 2023年05月28日 10:45:28
 */
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：依次表示流里面的每一个数据0
        //accept：对每个数据的处理操作
        //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[] arr = list.stream().toArray();
        //System.out.println(Arrays.toString(arr));

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

        //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[] arr = list.stream().toArray(value -> new String[value]);

        System.out.println(Arrays.toString(arr));
    }
}

10、Collect(Collector collector) 收集流中的数据，放到集合中（List Set Map）

package com.zjzakia01mystream;

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

/**
 * @author zjzaki
 * @create 2023年05月28日 10:45:28
 */
public class StreamDemo10 {

    public static void main(String[] args) {
        /*
          Collect(Collector collector) 收集流中的数据，放到集合中（List Set Map）

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

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

        //收集到Set集合当中
        //需求：把所有的男性收集起来
        Set<String> set = list.stream().filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toSet());

        System.out.println(set);

        //收集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) {

                        return s.split("-")[0];
                    }
                }, new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) {
                        return Integer.parseInt(s.split("-")[2]);
                    }
                }));

        System.out.println(map);

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

        System.out.println(collect);
    }
}

11、实战小练习

Actor.java

package com.zjzaki.a02test;

/**
 * @author zjzaki
 * @create 2023年05月28日 17:53:51
 */
public class Actor {

    private String name;
    private int age;

    public Actor() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

Test1.java

package com.zjzaki.a02test;

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

/**
 * @author zjzaki
 * @create 2023年05月28日 17:07:24
 */
public class Test1 {

    public static void main(String[] args) {
        /*
            定义一个集合，并添加一些整数 1,2,3,4,5,6,7,8,9,10
            过滤奇数，只留下偶数
            并将结果保存起来
         */
        //1.定义一个集合
        ArrayList<Integer> list = new ArrayList<>();
        //2.添加一些整数
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        //3.过滤奇数，只留下偶数
        //进行判断，如果是偶数，返回true保留
        List<Integer> collect = list.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(collect);
    }
}

Test2.java

package com.zjzaki.a02test;

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

/**
 * @author zjzaki
 * @create 2023年05月28日 17:13:21
 */
public class Test2 {

    public static void main(String[] args) {
        /*
            练习：
                创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄
                "zhangsan,23"
                "list,24"
                "wangwu,25"
                保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
         */
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("list,24");
        list.add("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);
    }
}

Test3.java

package com.zjzaki.a02test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author zjzaki
 * @create 2023年05月28日 17:33:47
 */
public class Test3 {

    public static void main(String[] args) {
        /*
            现在有两个ArrayList集合，分别存储6名男演员的名字和年龄以及6名女演员的名字和年龄
            姓名和年龄中间用逗号隔开
            比如：张三，23
            要求完成如下的操作：
                1.男演员只要名字为3个字的前两人
                2.女演员只要姓杨的，并且不要第一个
                3.把过滤后的男演员姓名和女演员姓名合并到一起
                4.将上一步的演员姓名封装成Actor对象
                5.将所有的演员对象都保存到List集合中
                备注：演员类Actor，属性有name,age

                男演员："蔡坤坤,24","叶齁咸,23","刘不甜,22","吴签,24","谷嘉,30","肖梁梁,27"
                女演员："赵小颖,35","杨颖,36","高元元,43","张天天,31","刘诗,35","杨小幂,33"
         */
        ArrayList<String> manList = new ArrayList<>();
        ArrayList<String> womenList = new ArrayList<>();
        //2.添加数据
        Collections.addAll(manList, "蔡坤坤,24", "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27");
        Collections.addAll(womenList, "赵小颖,35", "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33");
        //3.男演员只要名字为3个字的前两人
        Stream<String> stream1 = manList.stream()
                .filter(s -> s.split(",")[0].length() == 3)
                .limit(2);
        //4.女演员只要姓杨的，并且不要第一个
        Stream<String> stream2 = womenList.stream()
                .filter(s -> s.split(",")[0].startsWith("杨"))
                .skip(1);

        //5.把过滤后的男演员姓名和女演员姓名合并到一起
        //装成Actor对象
        //Stream.concat(stream1, stream2).map(new Function<String, Actor>() {
        //    @Override
        //    public Actor apply(String s) {
        //        String name = s.split(",")[0];
        //        int age = Integer.parseInt(s.split(",")[1]);
        //        return new Actor(name, age);
        //    }
        //}).forEach(s-> System.out.println(s));

        List<Actor> collect = Stream.concat(stream1, stream2)
                .map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
                .collect(Collectors.toList());
        System.out.println(collect);
    }
}