Stream流的基本知识点

Stream流

结合了Lambda表达式，简化集合、数组的操作

Stream流的使用步骤：

1.先得到一条Stream流（流水线），并把数据放上去

2.；利用Stream流中的API进行各种操作

过滤	转换	中间方法	方法调用完之后，还能继续进行方法调用
统计	打印	终结方法	方法调用完之后，就不能调用其他方法

1.得到流的方法

先得到一条Stream流，并把数据放上去

获取方式	方法名	说明
单列集合	default Streamstream()	Collection中的默认方法
双列集合	无	无法直接使用stream流
数组	public staticstream(T[] array)	Arrays工具类中的静态方法
一堆零散数据	public staticStreamof(T…values)	Stream接口中的静态方法

具体代码实现：

package streamMethod;

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

public class StreamMethod {
    public static void main(String[] args) {
        
        //1.单例集合
//        ArrayList<String> list = new ArrayList<>();
//        Collections.addAll(list, "张三", "李四", "王五", "赵六", "田七", "王五", "田七", "田七");
//        Stream<String>stream =list.stream();
//        stream.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
//        list.stream().forEach(s -> System.out.println(s));

 System.out.println("===============================");
        
        //2.创建双列集合
//        HashMap<String, Integer> map = new HashMap<>();
//        map.put("张三", 1);
//        map.put("李四", 2);
//        map.put("王五", 3);
        //keySet()获取
//        map.keySet().stream().forEach(s -> System.out.println(s));
        //entrySet()获取
//        map.entrySet().stream().forEach(s -> System.out.println(s));

 System.out.println("===============================");
        
        //创建数组
//        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//        String[] arr1 = {"张三", "李四", "王五", "赵六", "田七", "田七", "田七"};
//        Arrays.stream(arr).forEach(s -> System.out.println(s));
//        Arrays.stream(arr1).forEach(s -> System.out.println(s));

 System.out.println("===============================");
        
        
        //一堆零散的数组 public static<T> Stream<T>of(T...value)
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).forEach(s -> System.out.println(s));
        Stream.of("张三", "李四", "王五", "赵六", "田七", "田七", "田七").forEach(s -> System.out.println(s));
        //Stream接口中静态方法of的细节
        //方法的参数是一个可变的参数，可以传递一堆零散的数据，也可以传递数组
        //但是数组必须是引用数据类型，如果传递基本数据类型，是会把整个数组当做一个愿随放到Stream当中的
    }
}

2.流的中间方法

名称	说明
Sreamfilter(Predicate<?superT>predicate)	过滤
Streamlimit(long maxSize)	获取前几个元素
Streamskip(long n)	跳过前几个元素
Streamdistint()	元素去重，依赖（hashCode和equals方法）
staticStreamcontact(Stream a,Stream b)	合并a和b两个流为一个流
Stream map(Function<T,R>mapper)	转换流中的数据类型

注意1：中间方法，返回新的Stream流，原来的Stream的流只能使用一次，建议使用链式编程

注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据

package streamMethod;

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

public class StreamAmongMethod {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三", "张四亮", "张五钱", "赵六", "田七", "王五", "田七", "田七");
        ArrayList<String> list1 =new ArrayList<>();
        Collections.addAll(list1,"1","2","3");
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "张三-23", "张四亮-24", "张五钱-22", "赵六-23");
//        list.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.startsWith("张");
//            }
//        }).forEach(s -> System.out.println(s));
//        list.stream().filter(s -> s.startsWith("张"))
//                .filter(s -> s.length()==3)
//                .forEach(s -> System.out.println(s));
        //获得前三个元素‘
//        list.stream().limit(3).forEach(s -> System.out.println(s));
//        System.out.println("=============================");
//        //跳过前三个元素
//        list.stream().skip(3).forEach(s -> System.out.println(s));
//        System.out.println("=============================");
//            //去重
//        list.stream().distinct().forEach(s -> System.out.println(s));
//        System.out.println("=============================");
//        //合并两个集合
//        Stream.concat(list.stream(),list1.stream()).forEach(s -> System.out.println(s));

        //转换集合
        list2.stream().map(s -> s.split("-")[0]).forEach(s -> System.out.println(s));
    }
}

3.流的终结方法

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

package streamMethod;

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

public class StreamLastMethod {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        Collections.addAll(list, "张三-男-23", "张四亮-男-24", "张五钱-男-24", "赵六-女-21", "田七-女-22", "王五-男-23");
        //遍历
        list.stream().forEach(s -> System.out.println(s));

        //统计
//          long count = list.stream().count();
//        System.out.println(count);//统计多少元素
        //toArray()收集流的数据放到数组中
//        Object[] objects = list.stream().toArray();
//        for (Object object : objects) {
//            System.out.println(object);
//        }
        //收集到List集合中
        List<String> list1 = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toList());
        System.out.println(list1);
        //收集到Set集合中
        Set<String> list2 = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toSet());
        System.out.println(list2);
        //收集到Map集合中
        Map<String,Integer> list3 =list.stream().filter(s -> "男".equals(s.split("-")[1])).
                collect(Collectors.toMap(s -> s.split("-")[0], s -> Integer.parseInt(s.split("-")[2])));
        System.out.println(list3);
    }
}