JAVA - Stream 流

一、Stream 流

1.1 Stream 流的过滤操作

filter():返回由该流的元素组成的流，该元素与给定的谓词匹配；

• filter()是一个中间操作，一般适用于list集合,主要作用就是模拟sql查询，从集合中查询想要的数据。

示例：

import java.util.ArrayList;

public class StreamDemo {
   //要求打印出以'张'开头并且长度为三个字的名称
   public static void main(String[] args) {
       //初始化集合
       ArrayList<String> list = new ArrayList<>();
       list.add("张三");
       list.add("李四");
       list.add("张五四");
       list.add("王四");
       list.add("张七五");

       //使用加强 for 遍历并判断
       for (String s : list) {
           if( s.startsWith("张") && s.length() == 3)
           System.out.println(s);
       }

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

       //使用 stream 中的 filter 方法对集合进行过滤输出
       list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

1.2 Stream 流的生成方式

Stream 的生成流

//通过数据源（集合，数组等）生成流

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

public class StreamDemo2 {
   public static void main(String[] args) {
       //Collection 体系的集合可以使用默认方法 stream() 生成流
       List<String> list = new ArrayList<>();
       Stream<String> streamList = list.stream();

       Set<String> set = new HashSet<>();
       Stream<String> streamSet = set.stream();

       //Map 体系的集合间接的生成流
       Map<String,Integer> map = new HashMap<>();
       Stream<String> streamKey = map.keySet().stream();
       Stream<Integer> streamValue = map.values().stream();
       Stream<Map.Entry<String, Integer>> streamEntry = map.entrySet().stream();

       //数组可以通过 Stream 的静态方法来生成流
       String[] strArray = new String[1024];
       Stream<String> streamArray = Stream.of(strArray);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

1.3 Stream 流的中间操作

Stream 流的中间操作

//多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何的处理；

list.stream().filter(/* 条件 */);

//示例：
import java.util.ArrayList;

public class StreamDemo3 {
   public static void main(String[] args) {
       ArrayList<String> list = new ArrayList<>();
       list.add("张三");
       list.add("李四");
       list.add("张五四");
       list.add("王四");
       list.add("张七五");

       list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 终结流：执行终止操作会从流的流水线上生成结果,其结果可以是任何不是流的值,例如List、String等；

1.4 Stream 流中的常见中间操作方法

• Stream filter( Predicate predicate )：用于对流中的过滤操作；
• Stream limit( long maxSize )：返回一个包含该流的元素流；
• Stream skip( long num )：返回一个包含此流的其余部分丢弃的流的第（ 1 或 n ）元素后流；

import java.util.ArrayList;

public class StreamDemo {
  public static void main(String[] args) {
      ArrayList<String> list = new ArrayList<>();
      list.add("张三");
      list.add("李四");
      list.add("张五四");
      list.add("王四");
      list.add("张七五");

      //取前三个数据输出
      list.stream().limit(3).forEach(System.out::println);

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

      //跳过前三个元素，输出后面的数据
      list.stream().skip(3).forEach(System.out::println);

      //取前三个数据，并跳过一个数据输出
      System.out.println("============================");
      list.stream().limit(3).skip(1).forEach(System.out::println);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• static Stream concat( Stream a, Stream b )：合并流；
• Stream distinct()：返回一个包含不同的元素流（根据Object.equals(Object)）这个流；

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

public class StreamDemo5 {
  public static void main(String[] args) {
      ArrayList<String> list = new ArrayList<>();
      list.add("张三");
      list.add("李四");
      list.add("张五四");
      list.add("王四");
      list.add("张七五");

      //s1截取前三个数据，s2跳过两个数据
      Stream<String> s1 = list.stream().limit(3);
      Stream<String> s2 = list.stream().skip(2);
      //合并流操作
      Stream.concat(s1,s2).forEach(System.out::println);

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

      //因为 s1 和 s2 两个流已经执行过终结流，故需要重新赋值
      s1 = list.stream().limit(3);
      s2 = list.stream().skip(2);
      //合并流操作的同时将重复的数据去除
      Stream.concat(s1,s2).distinct().forEach(System.out::println);

  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

• Stream sorted()：返回由该流的元素组成的流，按自然顺序排序；
• Stream sorted( Comparator comparator )：返回一个包含该流的元素流，根据提供的 Comparator 排序；

import java.util.ArrayList;

public class StreamDemo {
   public static void main(String[] args) {
       ArrayList<String> list = new ArrayList<>();
       list.add("ansan");
       list.add("lisi");
       list.add("zhangwusi");
       list.add("wangsi");
       list.add("zhangqiwu");

       //使用自然排序
       list.stream().sorted().forEach(System.out::println);

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

       //使用比较器进行排序
       list.stream().sorted((s1,s2) -> {
           //根据长度比较
           int num = s1.length() - s2.length();
           //如果长度相等，则对比 ASCLL 码的差值
           int num2 = num == 0 ? s1.compareTo(s2) : num;
           //返回为正数表示前一个字符串排序优先级更低，负数则表示排序优先级更高，为零表示两个字符串相等
           return num2;
       }).forEach(System.out::println);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

• Stream map( Function mapper )：返回一个流，包括将给定函数应用到该流元素的结果；
• IntStream mapToInt( ToIntFunction mapper )：返回一个包含应用给定的功能，该流的元素的结果 IntStream ( 表示原始 int 流 );

import java.util.ArrayList;

public class StreamDemo7 {
   public static void main(String[] args) {
       ArrayList<String> list = new ArrayList<>();
       list.add("10");
       list.add("20");
       list.add("30");
       list.add("40");
       list.add("50");

       //使用 map() 将字符串数据转换为整数之后在控制台输出
       list.stream().map(Integer::parseInt).forEach(System.out::println);

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

       //使用 mapToInt() 将字符串数组转换为整数后求和并返回
       System.out.println(list.stream().mapToInt(Integer::parseInt).sum());
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.5 Stream 流常见的终结操作方法

Stream 流中的常见终结操作方法

• void forEach( Consumer action ):对该流的每个元素执行一个动作；
• long count()：返回流中的元素数；

import java.util.ArrayList;

public class StreamDemo1 {
   public static void main(String[] args) {
       ArrayList<String> list = new ArrayList<>();

       list.add("张三");
       list.add("李四");
       list.add("张五四");
       list.add("王四");
       list.add("张七五");

       //输出流中的每一个数据
       list.stream().forEach(System.out::println);
       //输出流中的数据个数
       System.out.println(list.stream().count());
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.6 Stream 流的收集操作

Stream 流的收集方法

• R collect( Collector collector )

工具类 Collectors 提供了具体的收集方式

• public static Collector toList()：把元素收集到 List 集合中；
• public static Collector toSet()：把元素收集到 Set 集合中；
• public static Collector toMap( Function keyMapper, Function valueMapper )：把元素收集到 Map集合中；

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo8 {
   public static void main(String[] args) {
       String[] strArrays = {
               "张三","李四","王五","赵六"
       };

       //使用 List 收集流
       List<String> listStream = Stream.of(strArrays).collect(Collectors.toList());
       System.out.println(listStream);
       System.out.println("===================================");

       //使用 Set 收集流
       Set<String> setStream = Stream.of(strArrays).collect(Collectors.toSet());
       System.out.println(setStream);
       System.out.println("===================================");

       //使用 Map 收集流，以数组的下标作为键值
       Map<Integer,String> mapStream = Stream.of(strArrays).collect(Collectors.toMap(s -> Arrays.binarySearch(strArrays,s) ,s -> s));
       System.out.println(mapStream);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28