Java8新特性——Stream API操作

Java8新特性——Stream API操作

1、什么是StreamAPI？

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 m Stream API (java.util.stream.*) 。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。

使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

---

流 (Stream) 到底是什么 呢 ？

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“ 集合讲的是 数据 ， 流讲的是 计算 ！”

注意 ：

1. Stream 自己不会存储元素。
2. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
3. Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

2、Stream API操作分类

无状态：

指元素的处理不受之前元素的影响；

有状态：指该操作只有拿到所有元素之后才能继续下去。

非短路操作：指必须处理所有元素才能得到最终结果；

短路操作：指遇到某些符合条件的元素就可以得到最终结果，如 A || B，只要A为true，则无需判断B的结果。

3、用法明细

流的常用创建方法

1、使用Collection下的 stream() 和 parallelStream() 方法

List list = new ArrayList<>();

Stream stream = list.stream(); //获取一个顺序流

Stream parallelStream = list.parallelStream(); //获取一个并行流
1
2
3
4
5

2、使用Arrays 中的 stream() 方法，将数组转成流

Integer[] nums = new Integer[10];

Stream stream = Arrays.stream(nums);
1
2
3

3、使用Stream中的静态方法：of()、iterate()、generate()

Stream stream = Stream.of(1,2,3,4,5,6);

Stream stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);

stream2.forEach(System.out::println); // 0 2 4 6 8 10

Stream stream3 = Stream.generate(Math::random).limit(2);

stream3.forEach(System.out::println);
1
2
3
4
5
6
7
8
9

4、使用 BufferedReader.lines() 方法，将每行内容转成流

BufferedReader reader = new BufferedReader(new FileReader("F:\\test_stream.txt"));

Stream lineStream = reader.lines();

lineStream.forEach(System.out::println);
1
2
3
4
5

5、使用 Pattern.splitAsStream() 方法，将字符串分隔成流

Pattern pattern = Pattern.compile(",");

Stream stringStream = pattern.splitAsStream("a,b,c,d");

stringStream.forEach(System.out::println);
1
2
3
4
5

整体创建实例：

    //创建Stream
    @Test
    public void test1() {
        //1.Collection 提供了两个方法  stream() 与 parallelStream()
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
 
        //2. 通过 Arrays 中的 stream() 获取一个数组流
        String[] strings = new String[10];
        Stream<String> stream2 = Arrays.stream(strings);
 
        //3. 通过 Stream 类中静态方法 of()
        Stream<String> stream3 = Stream.of("abc","666","???");
 
        //4. 创建无限流
        //迭代
        Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
        stream4.limit(5).forEach(System.out::println);
 
        //生成
        Stream.generate(() -> Math.random())
                .limit(5)
                .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

4、流的中间操作

常用的中间操作大体上可以分为三类：①筛选与切片；②映射；③排序

1、筛选与切片

filter：过滤流中的某些元素
　　limit(n)：获取n个元素
　　skip(n)：跳过n元素，配合limit(n)可实现分页
　　distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素

Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);

 
Stream<Integer> newStream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14

.distinct() //6 7 9 8 10 12 14

.skip(2) //9 8 10 12 14

.limit(2); //9 8

newStream.forEach(System.out::println);
1
2
3
4
5
6
7
8
9
10
11
12

2、映射

map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

List<String> list = Arrays.asList("a,b,c", "1,2,3");

  

//将每个元素转成一个新的且不带逗号的元素

Stream<String> s1 = list.stream().map(s -> s.replaceAll(",", ""));

s1.forEach(System.out::println); // abc 123

 
Stream<String> s3 = list.stream().flatMap(s -> {

//将每个元素转换成一个stream

String[] split = s.split(",");

Stream<String> s2 = Arrays.stream(split);

return s2;

});

s3.forEach(System.out::println); // a b c 1 2 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3、排序

sorted()：自然排序，流中元素需实现Comparable接口
sorted(Comparator com)：定制排序，自定义Comparator排序器

List<String> list = Arrays.asList("aa", "ff", "dd");

//String 类自身已实现Compareable接口

list.stream().sorted().forEach(System.out::println);// aa dd ff

  

Student s1 = new Student("aa", 10);

Student s2 = new Student("bb", 20);

Student s3 = new Student("aa", 30);

Student s4 = new Student("dd", 40);

List<Student> studentList = Arrays.asList(s1, s2, s3, s4);

  

//自定义排序：先按姓名升序，姓名相同则按年龄升序

studentList.stream().sorted(

(o1, o2) -> {

if (o1.getName().equals(o2.getName())) {

return o1.getAge() - o2.getAge();

} else {

return o1.getName().compareTo(o2.getName());

}

}

).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
29
30
31
32
33
34
35
36
37
38
39

4、消费

Student s1 = ``new` `Student(``"aa"``, ``10``);
Student s2 = ``new` `Student(``"bb"``, ``20``);
List studentList = Arrays.asList(s1, s2);
 
studentList.stream()
.peek(o -> o.setAge(``100``))
.forEach(System.out::println);
 
//结果：
Student{name=``'aa'``, age=``100``}
Student{name=``'bb'``, age=``100``}
1
2
3
4
5
6
7
8
9
10
11

5. 流的终止操作

匹配、聚合操作
　　allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false
　　noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false
　　anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false
　　findFirst：返回流中第一个元素
　　findAny：返回流中的任意元素
　　count：返回流中元素的总个数
　　max：返回流中元素最大值
　　min：返回流中元素最小值

List list = Arrays.asList(``1``, ``2``, ``3``, ``4``, ``5``);
 
boolean` `allMatch = list.stream().allMatch(e -> e > ``10``); ``//false
boolean` `noneMatch = list.stream().noneMatch(e -> e > ``10``); ``//true
boolean` `anyMatch = list.stream().anyMatch(e -> e > ``4``); ``//true
 
Integer findFirst = list.stream().findFirst().get(); ``//1
Integer findAny = list.stream().findAny().get(); ``//1
 
long` `count = list.stream().count(); ``//5
Integer max = list.stream().max(Integer::compareTo).get(); ``//5
Integer min = list.stream().min(Integer::compareTo).get(); ``//1　　
eam().findFirst().get(); ``//1
Integer findAny = list.stream().findAny().get(); ``//1
 
long` `count = list.stream().count(); ``//5
Integer max = list.stream().max(Integer::compareTo).get(); ``//5
Integer min = list.stream().min(Integer::compareTo).get(); ``//1　　
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18