Stream流的终结方法

Stream流的终结方法

void forEach(Consumer action)------->遍历

long count()--------->统计

toArray()--------->收集流中的数据，放到数组中

collect(Collector collector)----->收集流中的数据，放到集合中（List，Set，Map）

（1）收集到数组中的方法代码演示

package a08mystream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.IntFunction;

public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"顾拙言","夏希艾","梁承","顾飞","顾青裴","顾沉白","顾昀池","齐暮","陶淮南");
        //1.遍历
        //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));

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

        //3.收集
//        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));
         */

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

运行结果：

 

 （2）收集到集合中的方法代码演示

package a08mystream;

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

public class StreamDemo7 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"顾拙言-攻-15","夏希艾-受-14","梁承-攻-13","顾飞-攻-12","顾青裴-受-11","顾沉白-攻-10","顾昀池-攻-9","齐暮-受-8","陶淮南-受-7");
        //收集到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集合当中，键不能重复，否则会报错
        //谁作为键，谁作为值
        //键：姓名，值：数字
        Map<String, Integer> map = list.stream().filter(s -> "攻".equals(s.split("-")[1]))
                //toMap:参数1：键的生成规则；参数2：值的生成规则
                //参数1：Function泛型1：表示流中每一个数据的类型；泛型2：表示Map集合中键的数据类型
                //      方法apply形参：依次表示流里面的每一个数据
                //              方法体：生成键的代码
                //              返回值：已经生成的键
                //参数2：Function泛型1：表示流中每一个数据的类型；泛型2：表示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);

        //lambda表达式：
        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);
    }
}

运行结果：