一.Stream流的作用 

package com.njau.my_stream;

import java.util.ArrayList;

/**
 * 目标：认识Stream流
 * 案例：将以“张”开头的人名筛选出来到一个新的集合中去，再将其中三个字的名字的筛选出来到新集合中去
 */
public class StreamDemo1 {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("周芷若");
        names.add("张三丰");
        names.add("杨过");
        names.add("张无忌");
        names.add("赵敏");

    
        ArrayList<String> list = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("张")) {
                list.add(name);
            }
        }

        ArrayList<String> list1 = new ArrayList<>();
        for (String s : list) {
            if (s.length() == 3) {
                list1.add(s);
            }
        }

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


        names.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));
    }
}

 二.Stream流的思想

 

 

 三.单列集合使用Stream流

package com.njau.my_stream;

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

public class StreamDemo2 {
    public static void main(String[] args) {
        /*
            单列集合                default Stream<E>                   Collection中的默认方法
            双列集合                无                                   无法直接使用Stream流
            数组                   public static <T> Stream<T> stream(T[] array)      Arrays工具类中的静态方法
            一堆零散数据             public static <T> Stream<T> of(T...values)           Stream接口中的静态方法
         */
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"b","v","c");

        // 获取一条流水线，并把单列集合上的所有数据放在流水线上
        Stream<String> stream = list.stream();
        // s代表每一个要遍历的元素
        stream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });


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

    }
}

四.双列集合使用Stream流

package com.njau.my_stream;

import java.util.HashMap;

// 双列集合                无                                   无法直接使用Stream流
public class StreamDemo3 {
    public static void main(String[] args) {
        HashMap<String,Integer> map = new HashMap<>();
        map.put("adc",2);
        map.put("rww",4);
        map.put("revc",5);
        map.put("xsa",7);
        map.put("juyr",10);

        map.keySet().stream().forEach(key -> {
                Integer value = map.get(key);
                System.out.println(key + "=" + value);
        });

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

        map.entrySet().stream().forEach(stringIntegerEntry -> System.out.println(stringIntegerEntry));
    }
}

五.数组使用Stream流

package com.njau.my_stream;

import java.util.Arrays;

// 数组                   public static <T> Stream<T> stream(T[] array)      Arrays工具类中的静态方法
public class StreamDemo4 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8};

        String[] arr1 = {"a","b","c"};

        Arrays.stream(arr).forEach(s -> System.out.println(s));
        System.out.println("=================================");
        Arrays.stream(arr1).forEach(s -> System.out.println(s));
    }

}

六.零散数据使用Stream流

package com.njau.my_stream;

import java.util.stream.Stream;

//  一堆零散数据             public static <T> Stream<T> of(T...values)           Stream接口中的静态方法
public class StreamDemo5 {
    public static void main(String[] args) {
        Stream.of("a",1,"e",'s').forEach(s -> System.out.println(s));

        // of方法也可以用来处理引用类型的数组，但是不能处理非引用类型的数组，因为非引用类型的数组使用of方法不会自动装箱
        int[] arr1 = {1,1,4,5,3,6,8,3,8};

        String[] arr2 = {"s","x","4","rg"};

        Stream.of(arr2).forEach(System.out::println);
        Stream.of(arr1).forEach(System.out::println);   // [I@448139f0 会将数组整体作为一个参数传递给of方法，从而打印地址
    }
}