1.流的思想：

1. 集合与流的转换：
   • 可以将集合（如List、Set）转换为流（Stream），以便进行流式处理。
2. 中间操作（Intermediate Operations）：
   • 这些操作会返回一个新的流，可以进行链式操作，如filter（过滤）、map（转换）、sorted（排序）等。且建议使用链式编程。
3. 终止操作（Terminal Operations）：
   • 终止操作会消耗流，并产生一个最终的结果或副作用，如forEach（对每个元素执行操作）、collect（将流转换为其他形式，如集合）、reduce（聚合操作）等。
4. 不可变性：
   • Stream操作不会修改原始数据源，而是返回一个新的流或结果。
5. 惰性求值：
   • 流操作是惰性求值的，这意味着在执行终止操作之前，中间操作不会执行。这种设计可以提高效率，因为它允许跳过不必要的操作。

2.流的使用步骤：

1. 先得到一条Stream流，并把数据放上去；
2. 利用Stream流中的API进行各种操作
   • 中间方法：方法调用完毕后，还可以调用其他方法
   • 终结方法：最后一步，调用完毕后，不能在调用其他方法。

3.流的获取：

获取方式	方法名	说明
单列集合	default Stream stream()	Collection中的默认方法
双列集合	无	无法直接使用stream流 可以先转成单列集合(keySet、entrySet、values)
数组	public static Stream stream(T[] array)	Arrays工具类中的静态方法
一堆零散数据	public static Stream of(T… values)	Stream接口中的静态方法

示例：

//1.单列集合
        ArrayList<Integer> arrayList=new ArrayList<>();
        Collections.addAll(arrayList,1,2,5,6,3,7);

        arrayList.stream().forEach(s-> System.out.println(s));

        //2.双列集合
        HashMap<String,Integer> hashMap=new HashMap<>();
        hashMap.put("aaa",111);
        hashMap.put("bbb",222);
        hashMap.put("ccc",333);
        hashMap.put("ddd",444);

        hashMap.keySet().stream().forEach(s-> System.out.println(s));
        hashMap.values().stream().forEach(s-> System.out.println(s));
        hashMap.entrySet().stream().forEach(s-> System.out.println(s));

        //3.数组
        int[] arr={1,5,3,2,4};

        Arrays.stream(arr).forEach(s-> System.out.println(s));

        //4.零散数据
        Stream.of(5,9,3,2,7).forEach(e-> System.out.println(e));

4.流的中间方法

名称	说明
Stream filter(Predicate predicate)	过滤
Stream limit(long maxSize)	获取前几个元素
Stream skip(long n)	跳过前几个元素
Stream distinct()	元素去重，依赖(hashCode和equals方法)
static Stream concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream map(Function mapper)	转换流中的数据类型

示例：

        ArrayList<String> list = new ArrayList<>();
        list.add("Jason Hard");
        list.add("Jason Smith");
        list.add("Nick Jackson");
        list.add("Mike Trump");
        list.add("Jason Mask");


        list.stream()
                .filter(e->e.startsWith("Jason"))
                .filter(s->s.length()==10)
                .forEach(s->System.out.println(s));//Jason Hard ;Jason Mask

5.流的终结方法：

名称	说明
void forEach(Consumer action)	遍历
long count()	统计
toArray()	收集流中的数据，放到数组中
collect(Collector collector)	收集流中的数据，放到集合中

示例1：

ArrayList<String> list = new ArrayList<>();
list.add("Jason Hard");
list.add("Jason Smith");
list.add("Nick Jackson");
list.add("Mike Trump");
list.add("Jason Mask");

String[] arr=list.stream().toArray(value -> new String[value]);//value是数组的长度/元素的个数
System.out.println(Arrays.toString(arr));//[Jason Hard, Jason Smith, Nick Jackson, Mike Trump, Jason Mask]

示例2：collect

此处split的用法，详见JAVA-核心类-String相关 – CMD137’s Blog

对于collect为list和set的区别：set中不能有重复的元素、而list则可以。

有：

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

collect：

        //收集到list中
        List newlist= list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toList());
        newlist.stream().forEach(s-> System.out.println(s));//相比于set，有重复元素

        //收集到set中
        Set newset= list.stream()
                .filter(s->s.split("-")[1].equals("男"))
                .collect(Collectors.toSet());
        System.out.println(newset.toString());

单独说明toMap

对于.collect(Collectors.toMap(………))

toMap(键的规则，值的规则)：

• 参数一表示键的生成规则
  • Function：
    • 参数一（泛型）：表示流中每一个数据的类型
    • 参数二（泛型）：表示要转换成的Map集合中的键的数据类型
  • apply：
    • 形参：依次表示流的每一个数据
    • 方法体：生成键的代码，最后要返回键
• 键参数二表示值的生成规则
  • Function：
    • 参数一（泛型）：表示流中每一个数据的类型
    • 参数二（泛型）：表示要转换成的Map集合中的值的数据类型
  • apply：
    • 形参：依次表示流的每一个数据
    • 方法体：生成值的代码，最后要返回值

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,
                "张无忌-男-15", "周芷若-女-14", "赵敏-女-13",
                "张强-男-20", "张三丰-男-100", "张翠山-男-40", "张良-男-35",
                "王二麻子-男-37", "谢广坤-男-41"
        );//注意此处键不能重复



        //收集到map中
        Map newmap=list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toMap(new Function<String, String>() {
                                              @Override
                                              public String apply(String string) {

                                                  return string.split("-")[0];
                                              }
                                          },
                                            new Function<String, Integer>() {
                                                @Override
                                                public Integer apply(String string) {
                                                    return Integer.parseInt(string.split("-")[2]);
                                                }
                                            }));
        System.out.println(newmap.toString());
//{张强=20, 张良=35, 张翠山=40, 王二麻子=37, 张三丰=100, 张无忌=15, 谢广坤=41}

    }