Java:Stream流

目录

Stream流

1、Stream流的使用步骤

2、Stream流的获取方式

3、Stream流的中间方法

4、Stream流的终结方法

---

Stream流

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

1、Stream流的使用步骤

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

2、使用中间方法对流水线上的数据进行操作

3、使用终结方法对流水线上的数据进行操作

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

过滤	转换	中间方法	方法调用完毕之后，还可以调用其他方法
统计	打印	终结方法	最后一步，调用完毕之后，不能调用其他方法

2、Stream流的获取方式

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

单列集合

        List<String> list = new ArrayList<>();
        Collections.addAll(list,"a","s","d","f");
        //获取一条流水线，并把数据放在流水线上
        Stream<String> stream = list.stream();
        //使用终结方法打印流水线所有数据
        stream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println("-----------------");
        //简化
        list.stream().forEach(s -> System.out.println(s));

双列集合

        //1.创建双列集合
        HashMap<String,Integer> hm = new HashMap<>();
        //2.添加数据
        hm.put("aaa",111);
        hm.put("bbb",222);
        hm.put("ccc",333);
        hm.put("ddd",444);
        //3.第一种获取stream流
        // hm.keySet().stream( ).forEach(s -> system.out.println(s)) ;
        //4.第二种获取stream流
        hm.entrySet().stream( ).forEach(s-> System.out.println(s)) ;

数组

         //1.创建数组
        int[] arr1 = {1,2,3,4,5};
        String[] arr2 = {"a","b","c"};
        //2.获取stream流
        Arrays.stream( arr1).forEach(s-> System.out.println(s)) ;
        System.out.println( "-----------------------");
        Arrays.stream( arr2).forEach(s-> System.out.println(s));

零散数据

Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));
System.out.println("-----------------");
Stream.of("a","b","c").forEach(s-> System.out.println(s));

注意:

Stream接口中静态方法of的细节

方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组，但是数组必须是引用数

据类型的，如果传递基本数据类型，是会把整个数组当做一个元素，放到Stream当中。

3、Stream流的中间方法

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

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

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

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌","周芷若", "赵敏" ,"张强","张三丰","张翠山","张良","王二麻子","谢广坤");
//filter过滤把张开头的留下，其余数据过滤不要
list.stream().filter(new Predicate<String>() {
      @Override
       public boolean test(String s) {
            //如果返回值为true，表示当前数据留下
            //如果返回值为false，表示当前数据舍弃不要
            return s.startsWith("张");
       }
   }).forEach(s -> System.out.println(s));
System.out.println("-----------------");
//简化 
//是否有张，长度是否等于3
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
System.out.println("-----------------------");
//获取前几个元素
list.stream().limit(3).forEach(s -> System.out.println(s));
System.out.println("--------------------");
//跳过前几个元素
list.stream().skip(4).forEach(s -> System.out.println(s));
System.out.println("--------------------");
//元素去重
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌","张无忌","张无忌","张强","张三丰","张举山","张良","王二麻子","谢广坤");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2,"周芷若","赵敏");
// distinct 元素去重，依赖(hashcode和equals方法)
list1.stream().distinct() .forEach(s -> System.out.println( s)) ;
System.out.println("--------------------");
//合并两个流
Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));

4、Stream流的终结方法

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

遍历

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌","周芷若", "赵敏" ,"张强","张三丰","张翠山","张良","王二麻子","谢广坤");
// 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));

统计

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

收集流中的数据，放到数组中

        //空参
        Object[] objects = list.stream().toArray();
        System.out.println(Arrays.toString(objects));

        //有参
        //IntFunction的泛型:具体类型的数组
        // apply的形参:流中数据的个数，要跟数组的长度保持一致
        // apply的返回值:具体类型的数组
        //方法体:就是创建数组

        //toArray方法的参数的作用:负责创建一个指定类型的数组
        // toArray方法的底层，会依次得到流里面的每一个数据，并把数据放到数组当中
        // toArray方法的返回值:是一个装着流里面所有数据的数组
        //匿名内部类
        String[] strings = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(Arrays.toString(strings));
        //lambda表达式的写法
        String[] strings1 = list.stream().toArray(value -> new String[value]);
        System.out.println(Arrays.toString(strings1));

收集流中的数据，放到集合中

         ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌-男-20","周芷若-女-20");
        //收集在list集合中
        List<String> collect = list.stream().collect(Collectors.toList());
        System.out.println(collect);
        //收集在set集合中,可以去除重复元素
        Set<String> collect1 = list.stream().collect(Collectors.toSet());
        System.out.println(collect1);
        //收集在map集合中
        Map<String, Integer> collect2 = list.stream().collect(Collectors.toMap(
                s -> s.split("-")[0],
                s -> Integer.parseInt(s.split("-")[2])));
        System.out.println(collect2);