Java - Stream

Stream流的作用

• 简化集合和数组操作的API ，结合Lambda表达式

Stream流的思想步骤

• 先得到集合或数组的流
• 把元素放上去
• 然后用Stream简化的API操作元素

package Stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

public class Demo01 {

    public static void main(String[] args) {

        // 从集合中挑选出 姓张 名字三位的 存储到新集合中
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰","赵丽颖","张丰毅","张起灵","宋祖儿");

        List<String> newList = new ArrayList<>();
        for (String s : list) {
           if(s.startsWith("张")&&s.length()==3){
               newList.add(s);
           }
        }
        System.out.println(newList);
		
		//Stream流
        Stream<String> stream = list.stream();
        Stream<String> 张 = stream.filter(s -> s.startsWith("张") && s.length() == 3);
        张.forEach(s-> System.out.println(s));
        
        //Lambda表达式简化
        list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(s-> System.out.println(s));

    }
}

Stream流的三类方法

• 获取Stream流
  • 创建一条流水线，并把数据放到流水线上准备进行操作
• 中间方法
  • 流水线上的操作，一次操作完毕后，还可以继续进行其他操作
• 终结方法
  • 一个Stream流只能有一个终结方法，是流水线上的最后一个操作

集合获取Stream流的方法

• 使用Collection接口中的默认方法
• default Stream stream()

数组获取Stream流的方法

• public static Stream stream(T[] array)
• public static Stream of(T… values)

package stream;

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

public class Demo02 {

    public static void main(String[] args) {
        //Collection获取流
        Collection<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

        //Map集合获取流
        Map<String,Integer> map = new HashMap<>();
        //1.
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        //2.
        Stream<Map.Entry<String, Integer>> stream1 = map.entrySet().stream();

        //数组获取流
        String[] str = {"a","b","c"};
        //1.
        Stream<String> stream2 = Arrays.stream(str);
        //2.
        Stream<String> str1 = Stream.of(str);

    }
}

Stream流的常用中间方法

package stream;

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

public class Demo03 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"aa","abc","cdd","dddd");

        //Stream<T> filter(Predicate<? super T> predicate); 对流中的数据进行过滤
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("a");
            }
        });
        list.stream().filter(s-> s.startsWith("a")).forEach(s-> System.out.println(s));//out: aa abc
        list.stream().filter(s-> s.startsWith("a")).forEach(System.out::println); //out: aa abc

        //long count(); 统计个数
        long count = list.stream().count(); //out: 4
        System.out.println(count);

        //Stream<T> limit(long maxSize);  maxSize指该流最多元素个数
        list.stream().filter(s->s.startsWith("a")).limit(1).forEach(System.out::println); //out: aa

        //map 加工
        //<R> Stream<R> map(Function<? super T, ? extends R> mapper);   修改流中元素, R加工后的元素类型
        list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return "搭嘎好："+s;
            }
        });
        list.stream().map(s-> "搭嘎好："+s).forEach(System.out::println); //out: 搭嘎好：aa 搭嘎好：abc 搭嘎好：cdd 搭嘎好：dddd
        list.stream().map(new Function<String, Student>() {
           @Override
           public Student apply(String s){
               return new Student(s);
           }
        }).forEach(System.out::println);
        //Lambda简化
        list.stream().map(s->new Student(s)).forEach(s-> System.out.println(s));//out: student:aa student:abc student:cdd student:dddd
        //简化 构造器引用  方法引用
        list.stream().map(Student::new).forEach(System.out::println);//out: student:aa student:abc student:cdd student:dddd

        //合并流
        //public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
        Stream<String> stream1 = list.stream();
        Stream<String> stream2 = list.stream();
        Stream<String> stream3 = Stream.concat(stream1,stream2);
        stream3.forEach(System.out::println);//out:

        //去重复
        list.stream().distinct().forEach(System.out::println);

    }
}

class Student{
    private String name;
    public Student(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String toString(){
        return "student"+":"+this.name;
    }
}

• 中间方法也称为非终结方法，调用完成后返回新的流，支持链式编程。
• 并不会修改原集合或数组中的元素

Stream流的终结方法

•   //void forEach(Consumer<? super T> action);
    list.stream().forEach(System.out::println);
  

•   //long count();
    list.stream().count();
  

• 终结方法后流不再可以使用

Stream流转为集合、数组

package stream;

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

public class Demo04 {

   public static void main(String[] args) {

       List<String> list = new ArrayList();
       Collections.addAll(list,"abc","acb","bac","bca");

       //<R, A> R collect(Collector<? super T, A, R> collector);
       List<String> collect = list.stream().collect(Collectors.toList());

       Set<String> collect1 = list.stream().collect(Collectors.toSet());

   }
}

参考资料

B站黑马视频