Stream流

Stream流

1Stream概述

认识

• 先获取一个集合或数组 等的Stream流（一根传送带）
• 把元素放上去
• 然后用这个Stream流的 简化API 来方便的操作元素

Stream流：方便操作集合/数组的手段；

集合/数组：开发的目的；

三类方法：

• 1获取Stream流

  • 获取一条流水线，并把数据放在这条流水线上工作；

• 2中间方法

  • 流水线上的操作。一次操作完，可以继续操作；（链式编程）

• 3终结方法

  • 一个Stream流只能 有一个终结方法，是流水线上的最后一个操作； 即将Stream中元素转为 集合或数组

特点：

• 中间方法是非终结方法，调用完后返回新的Stream流可以继续用，支持链式编程
• Stream流中无法直接 修改集合，数组中的数据

2获取Stream流

2.1数组

• public static< T > Stream< T > of(T… values)

  //public static<T> Stream<T> of(T... values)
  Stream<String> stringStream = Stream.of(s);
  Stream<String> stringStream1 = Stream.of("青苹果","红苹果","烂苹果");
  stringStream1.forEach(System.out::println);	
  

• Arrays.stream(数组)

  String[] s = new String[]{"周芷若","灭绝","赵敏"};
  Stream<String> arrayStream = Arrays.stream(s);
  arrayStream.forEach(System.out::println);
  

2.2集合

• 1Collection

  • Collection对象.stream()

    Collection<String> collection = new ArrayList<>();
    Stream<String> collectionStream = collection.stream();
    

• 2Map

  • 利用 Collection对象.stream() , 获取键流，值流

    Map<String,Integer> map = new HashMap<>();
    //键流
    Stream<String> keyStream = map.keySet().stream();
    //值流
    Stream<Integer> valueStream = map.values().stream();
    

  • 键值对流 Map对象.entrySet().stream()

    Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();
    

3中间方法

方法	描述
Stream < T > filter ( Predicate <? super T> predicate)	用于对流中的数据进行过滤
Stream< T > limit (long maxSize)	获取前几个元素
Stream< T > skip（long n）	跳过前几个元素
Stream< T > distinct（）	去重。依赖（equals和hashCode重写）
static < T > Stream< T > concat(Stream a, Stream b)	合并a和 b两个流为一个流

3.1filter筛选

按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作

Stream<T> filter(Predicate<? super T> predicate)

List<String> list = new ArrayList<>();
Collections.addAll(list,"周芷若","张无忌","殷素素","赵敏","张三丰");
//过滤  filter()
list.stream().filter(new Predicate<String>() {// Predicate @FunctionalInterface 
    @Override
    public boolean test(String s) {
        return s.startsWith("张");
    }
}).forEach(System.out::println);             //如果前后 都使用s , 则可化简

//lambda表达式
list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);

3.2count大小

List<String> list = new ArrayList<>();
Collections.addAll(list,"周芷若","张无忌","殷素素","赵敏","张三丰");
//大小 Long count()
long num = list.stream().count();             //long !!!
System.out.println(num);

3.3limit限制

List<String> list = new ArrayList<>();
Collections.addAll(list,"周芷若","张无忌","殷素素","赵敏","张三丰");
//limit(n)  限制Stream流大小num，即取前num个元素的Stream流，
//stream对象.collect(Collector)     终结方法  把元素收到 集合中
System.out.println(list.stream().limit(2).collect(Collectors.toList()));

3.4skip跳过

//skip(n)  跳过n个元素
System.out.println(list.stream().skip(3).collect(Collectors.toList()));

3.5map加工

List<String> list = new ArrayList<>();
Collections.addAll(list,"周芷若","张无忌","殷素素","赵敏","张三丰");

list.stream().map(new Function<String, Object>() {		// Function @FunctionalInterface 
    @Override
    public Object apply(String s) {  //s为Stream流的元素	
        return "交大"+s;				//拼接,并放回
    }
}).forEach(System.out::println);

//lambda表达式
list.stream().map(s -> "交大"+s).forEach(System.out::println);

有参构造器

List<String> list = new ArrayList<>();
Collections.addAll(list,"周芷若","张无忌","殷素素","赵敏","张三丰");

list.stream().map(new Function<String, Student>() {
    @Override
    public Student apply(String s) {
        return new Student(s);			 //构造器 Student(String name)
    }
});
//lambda表达式化简
list.stream().map(s -> new Student(s));
//最终
list.stream().map(Student::new);

3.6distinct去重

List<String> list = new ArrayList<>();
Collections.addAll(list,"周芷若","张无忌","殷素素","赵敏","张三丰");

list.add("张三丰");
System.out.println(list);
System.out.println(list.stream().distinct().collect(Collectors.toList()));

运行结果：

[周芷若, 张无忌, 殷素素, 赵敏, 张三丰, 张三丰]
[周芷若, 张无忌, 殷素素, 赵敏, 张三丰]

3.7concat合并

Stream<String> s = Stream.of("java","Java");
Stream<String> l = list.stream();
//public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)  合并
Stream<Object> concat1 = Stream.concat(s, l);
System.out.println(concat1.collect(Collectors.toList()));

3.8排序

List<Integer> list = new ArrayList<>();
Collections.addAll(list,1,2,3,4,5,2,1,9);
//sorted 排序 自定义排序规则
list.stream().sorted(new Comparator<>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2; //升序
    }
}).forEach(System.out::println);

4终结方法

收集Stream流：把Stream流操作后的结果数据，转化为集合或者数组中

1 Stream流的收集方法：

• R collect (Collector collector)

2 针对上述需要的 形参Collector ，可以使用Collectors工具类的具体收集方式：

方法	描述
public static < T > Collector toList()	把元素收集到List集合中
public static < T > Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper , Function valueMapper)	把元素收集到Map集合中

List集合

List<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张三丰");
//List
Stream s1 = list.stream().filter(s -> s.startsWith("张"));
List<String> s = (List<String>) s1.collect(Collectors.toList());

Set集合

Set<String> set = list.stream().collect(Collectors.toSet());
System.out.println(set);

Map

List<String> list = new ArrayList<>();
Collections.addAll(list,"法外:张三","斥候:提莫","枝江:学院");
//收集
Map<String, String> map = list.stream().collect(Collectors.toMap(
    //第一个lambda表达式就是如何获取到Map中的键
        s -> s.split(":")[0],		
     //第二个lambda表达式就是如何获取Map中的值
        s -> s.split(":")[1]
));
//遍历
map.forEach((s,  s1) ->  System.out.println(s+"=>"+s1) );

注意：

• Stream对象 每次操作或收集 后， 就无发使用(只能使用一次) stream has already been operated upon or closed

参考

第八章_集合(3)_Map集合&Stream流_map stream-CSDN博客

Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合_java8 stream:2万字20个实例-CSDN博客