可变参数与不可变集合；Stream流的生成、中间方法、终结方法以及收集Stream流

1. 可变参数

可变参数介绍：

• 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
• 方法的参数类型已经确定，个数不确定，可以使用可变参数
• 方法的参数变量实际上是一个数组

public class Test01 {
    public static void main(String[] args) {
        System.out.println(sum(10,20,30,40,50));
        System.out.println(sum(10,20,30,40,50,60));
        System.out.println(sum(10,20,30,40,50,60,70));
        System.out.println(sum(10,20,30,40,50,60,70,80,90,100));
    }
    //arr实际上就是一个数组容器
    public static int sum(int... arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
}

不可变集合：

• 在List、Set、Map接口中，都存在of方法，可以创建一个不可变的集合
• 不可变集合不能添加,不能删除,不能修改
• 不可变集合常作为参数，传入一般集合的带参构造方法中，实现集合的批量添加，不用再写多个add方法

import java.util.*;

public class Test02 {
    public static void main(String[] args) {
        //List.of方法来创建一个不可变的list集合，of方法的形参就是一个可变参数
        List<String> list1 = List.of("李白", "杜甫", "王维", "王安石", "苏东坡");
        ArrayList<String> list = new ArrayList<>(list1);
        System.out.println(list);//[李白, 杜甫, 王维, 王安石, 苏东坡]

        //Set.of传递的参数当中，不能存在重复的元素
        TreeSet<Integer> set = new TreeSet<>(Set.of(3, 9, 4, 5, 1, 2, 7, 6, 8));
        System.out.println(set);//[1, 2, 3, 4, 5, 6, 7, 8, 9]

        //Map.of创建一个具有指定元素的Map集合对象
        HashMap<String, Integer> map1 = new HashMap<>(Map.of("四川大学", 985,
                "西南交通大学", 211));
        System.out.println(map1);//{西南交通大学=211, 四川大学=985}
        //ofEntries方法创建一个具有指定元素的Map集合对象
        //ofEntries方法会把键值对封装成一个Entry对象,再把这个Entry对象添加到集合当中
        TreeMap<String, Integer> map2 = new TreeMap<>(Map.ofEntries(
                                        Map.entry("电子科技大学", 985),
                                        Map.entry("西南财经大学", 211)));
        System.out.println(map2);//{电子科技大学=985, 西南财经大学=211}
    }
}

2. Stream流 

Stream流把真正的函数式编程风格引入到Java代码中，使得代码更加简洁

可以将Stream流看成是一条流水线，对流水线上的数据进行各种操作

Stream流的三类方法：生成Stream流（创建一条流水线 ）、中间方法（流水线上的操作 ）、终结方法（流水线上的最后一个操作 ）

2.1 生成Stream流

• Collection体系集合：使用默认方法stream()生成流， default Stream<E> stream()
• Map体系集合：把Map转成Set集合，间接的生成Stream流
• 数组：通过Arrays中的静态方法stream生成流
• 同种数据类型的多个数据：通过Stream接口的静态方法of(T... values)生成流

import java.util.*;
import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream()生成流
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();

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

        //Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<String, Integer>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //数组可以通过Arrays中的静态方法stream生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Arrays.stream(strArray);

        //同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);
    }
}

2.2 Stream流中间方法

方法名	说明
Stream<T> filter(Predicate predicate)	用于对流中的数据进行过滤
Stream<T> limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
Stream<T> skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream<T> distinct()	去除重复元素（根据Object.equals(Object) ）组成的流

filter代码演练：

import java.util.*;
import java.util.function.Predicate;

public class Test01 {
    public static void main(String[] args) {
        /*Stream<T> filter(Predicate predicate)：过滤
        Predicate接口中的方法	boolean test(T t)：对给定的参数进行判断，返回一个布尔值*/
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("宋青书");
        list.add("张良");
        list.add("周芷若");
        //匿名内部类实现
        list.stream().filter(
                new Predicate<String>() {
                    @Override
                    public boolean test(String s) {
                        boolean result = s.startsWith("张");
                        return result;
                    }
                }
        ).forEach(s-> System.out.println(s));

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

    }
}

limit、skip、concat和distinct代码演示：

public class StreamDemo03 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);

        //需求2：跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);

        //需求3：合并需求1和需求2得到的流，并把结果在控制台输出
        Stream.concat(s1,s2).forEach(s-> System.out.println(s));

        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));
    }
}

2.3 Steam流的终结操作方法

终结操作的意思是，执行完此方法之后，Stream流将不能再执行其他操作

方法名	说明
void forEach(Consumer action)	对此流的每个元素执行操作
long count()	返回此流中的元素个数

2.4 Stream流的收集操作方法

对数据使用Stream流的方式操作完毕后，可以把流中的数据收集到集合中

示例代码：

package com.yulu.feng.stream;

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

public class Test02 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>(
                List.of(1, 2, 3, 6, 9, 5, 7, 8, 4));
        //根据list集合生成流，筛选出所有偶数收集到list1集合当中
        List<Integer> list1 = list.stream().filter(s -> s % 2 == 0)
                                            .collect(Collectors.toList());
        System.out.println(list1);
        //根据list集合生成流，筛选出所有偶数收集到set集合当中
        Set<Integer> set = list.stream().filter(s -> s % 2 == 0)
                                        .collect(Collectors.toSet());
        System.out.println(set);

        ArrayList<String> listmap = new ArrayList<>(
                List.of("小龙女,18", "王语嫣,16", "郭襄,15", "黄蓉,35"));
        //将list集合中的字符串分割后，筛选小于30岁的存入map集合
        Map<String, Integer> map = listmap.stream().
                filter(s -> Integer.parseInt(s.split(",")[1]) < 30)
                .collect(Collectors.toMap(
                        s -> s.split(",")[0],
                        s -> Integer.parseInt(s.split(",")[1]
                        )));
        System.out.println(map);
    }
}

2.5 Stream流练习

map方法：返回一个流，该流包含将给定函数应用于此流的元素的结果。

sorted方法：返回由此流的元素组成的流，根据提供的 Comparator进行排序。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamTest2 {

    public static void main(String[] args) {
        //1.定义一个字符串数组
        String[] arr = {"123","456","777","345","345","222","999","222","110","120","567"};
        //2.通过数组获取流，把数组中的元素转换为Integer类型
        Arrays.stream(arr).map(s->Integer.parseInt(s)).forEach((Integer i)->{
            System.out.println(i);
        });
        List<Integer> list = Arrays.stream(arr).map(s -> Integer.parseInt(s)).collect(Collectors.toList());
        System.out.println(list);
        System.out.println("------------------------------------");
        //3.对元素按照降序排列
        Arrays.stream(arr).sorted((s1, s2) -> Integer.parseInt(s1) - Integer.parseInt(s2)).forEach(
                s -> System.out.println(s)
        );
        System.out.println("------------------------------------");

        //4.截取前面6个
        Arrays.stream(arr).limit(6).forEach(s -> System.out.println(s));
        System.out.println("------------------------------------");
        //5.跳过前面3个
        Arrays.stream(arr).skip(3).forEach(s -> System.out.println(s));
        System.out.println("------------------------------------");

        //6.去除重复元素
        Arrays.stream(arr).distinct().forEach(s -> System.out.println(s));
        System.out.println("------------------------------------");
        //7.把元素收集成List集合
        List<String> list2 = Arrays.stream(arr).collect(Collectors.toList());
        System.out.println(list2);
        System.out.println("------------------------------------");
        //8.遍历打印集合中的元素
        Arrays.stream(arr).forEach(s -> System.out.println(s));
    }
}

 如有错误欢迎留言评论，及时更正。2021年6月6日 羽露风