Steram流的部分使用

最新推荐文章于 2024-12-15 15:46:41 发布

云鼎

最新推荐文章于 2024-12-15 15:46:41 发布

阅读量2.2k

点赞数 1

分类专栏： java基础文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_41358110/article/details/117651827

版权

java基础专栏收录该内容

3 篇文章

订阅专栏

一、stream是jdk1.8特性
二、Stream流的使用
2.1、生成流
通过数据源(集合,数组等)生成流
list.stream()
2.2、中间操作
一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
filter()
2.3、终结操作
一个流只能有一个终结操作，当这个操作执行后，流就被使用"光"了，无法再被操作。所以这必定是流的最后一个操作
forEach
2.4、案例

public class Demo1 {
    
    public static void main(String[] args) {
        // 1. 创建一个集合，存储多个字符串元素
        // 2. 把集合中所有以"张"开头的元素存储到一个新的集合
        // 3. 把"张"开头的集合中的长度为3的元素存储到一个新的集合
        // 4. 遍历上一步得到的集合
        
        // 创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        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
26
27

三、Stream流的常见生成方式
Collection体系的集合可以使用默认方法stream()生成流

default Stream stream()

Map体系的集合间接的生成流

数组可以通过Stream接口的静态方法of(T… values)生成流

 public class Demo2 {

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

         //Map体系的集合间接的生成流
         Map<String, Object> map = new HashMap<>();
         Set<String> keys = map.keySet();
         Collection<Object> values = map.values();
         Set<Map.Entry<String, Object>> entries = map.entrySet();

         Stream<String> stream = keys.stream();
         Stream<Object> stream1 = values.stream();
         Stream<Map.Entry<String, Object>> stream2 = entries.stream();

         //数组可以通过Stream接口的静态方法of(T... values)生成流

         String[] arr = new String[10];
         Stream<String> stream3 = Stream.of(arr);
         Stream<Integer> stream4 = Stream.of(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
25
26
27

四、Stream流的常见中间操作方法
Stream filter(Predicate predicate)：用于对流中的数据进行过滤
Predicate接口中的方法 boolean test(T t)：对给定的参数进行判断，返回一个布尔值
Stream limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
Stream skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static Stream concat(Stream a, Stream b)：合并a和b两个流为一个流
Stream distinct()：返回由该流的不同元素（根据Object.equals(Object) ）组成的流
Stream sorted()：返回由此流的元素组成的流，根据自然顺序排序
Stream sorted(Comparator comparator)：返回由该流的元素组成的流，根据提供的Comparator进行排序
Stream map(Function mapper)：返回由给定函数应用于此流的元素的结果组成的流
Function接口中的方法 R apply(T t)
IntStream mapToInt(ToIntFunction mapper)：返回一个IntStream其中包含将给定函数应用于此流的元素的结果
IntStream：表示原始 int 流
ToIntFunction接口中的方法 int applyAsInt(T value)
五、Stream流的常见终结操作方法
void forEach(Consumer action)：对此流的每个元素执行操作
Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作
long count()：返回此流中的元素数
六、案例

6.1、案例 limit,skip
public class Demo3 {
    
    public static void main(String[] args) {
        // 1. 创建一个集合,存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        
        System.out.println("--------取前3个数据在控制台输出--------");
        list.stream().limit(3).forEach(System.out::println);
        
        System.out.println("--------跳过3个元素，把剩下的元素在控制台输出--------");
        list.stream().skip(3).forEach(System.out::println);
        
        System.out.println("--------跳过2个元素，把剩下的元素中前2个在控制台输出--------");
        list.stream().skip(2).limit(2).forEach(System.out::println);
        
    }
    
}

    输出结果：

    --------取前3个数据在控制台输出--------
    林青霞
    张曼玉
    王祖贤
    --------跳过3个元素，把剩下的元素在控制台输出--------
    柳岩
    张敏
    张无忌
    --------跳过2个元素，把剩下的元素中前2个在控制台输出--------
    王祖贤
    柳岩
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
6.2、案例 concat,distinct
public class Demo4 {
    
    public static void main(String[] args) {
        // 1. 创建一个集合,存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        
        System.out.println("--------取前4个数据组成一个流--------");
        Stream<String> s1 = list.stream().limit(4);
        s1.forEach(System.out::println);
        
        System.out.println("--------跳过2个数据组成一个流--------");
        Stream<String> s2 = list.stream().skip(2);
        s2.forEach(System.out::println);
        //
        System.out.println("--------合并s3和s4的流，并把结果在控制台输出--------");
        Stream<String> s3 = list.stream().limit(4);
        Stream<String> s4 = list.stream().skip(2);
        Stream.concat(s3, s4).forEach(System.out::println);
        //
        System.out.println("--------合并s5和s6的流，并把结果在控制台输出，要求字符串元素不能重复--------");
        Stream<String> s5 = list.stream().limit(4);
        Stream<String> s6 = list.stream().skip(2);
        Stream.concat(s5, s6).distinct().forEach(System.out::println);
        
    }
    
}


    输出结果：

    --------取前4个数据组成一个流--------
    林青霞
    张曼玉
    王祖贤
    柳岩
    --------跳过2个数据组成一个流--------
    王祖贤
    柳岩
    张敏
    张无忌
    --------合并s3和s4的流，并把结果在控制台输出--------
    林青霞
    张曼玉
    王祖贤
    柳岩
    王祖贤
    柳岩
    张敏
    张无忌
    --------合并s5和s6的流，并把结果在控制台输出，要求字符串元素不能重复--------
    林青霞
    张曼玉
    王祖贤
    柳岩
    张敏
    张无忌
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
6.3、案例 sorted
public class Demo5 {
    
    public static void main(String[] args) {
        // 1. 创建一个集合,存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("ainqingxia");
        list.add("zhangmanyu");
        list.add("bangzuxian");
        list.add("liuyan");
        list.add("changmin");
        list.add("zhangwuji");
        System.out.println("--------按照字母顺序把数据在控制台输出--------");
        
        list.stream().sorted().forEach(System.out::println);
        
        System.out.println("--------按照字符串长度把数据在控制台输出--------");
        
        list.stream().sorted((s1, s2) -> {
            int i = s1.length() - s2.length();
            int i2 = i == 0 ? s1.compareTo(s2) : i;
            return i;
        }).forEach(System.out::println);
        
    }
    
}

    输出结果：

    --------按照字母顺序把数据在控制台输出--------
    ainqingxia
    bangzuxian
    changmin
    liuyan
    zhangmanyu
    zhangwuji
    --------按照字符串长度把数据在控制台输出--------
    liuyan
    changmin
    zhangwuji
    ainqingxia
    zhangmanyu
    bangzuxian
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
40
41
42
43
44
45
6.4、案例 mapToInt,sum
public class Demo6 {
    
    public static void main(String[] args) {
        // 创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");
        
        System.out.println("--------将集合中的字符串数据转换为整数之后在控制台输出--------");
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        
        System.out.println("--------返回此流中元素的总和--------");
        int sum = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
        
    }
    
}

    输出结果：

    --------将集合中的字符串数据转换为整数之后在控制台输出--------
    10
    20
    30
    40
    50
    --------返回此流中元素的总和--------
    150
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
6.5、案例 collect
public class Demo7 {
    
    public static void main(String[] args) {
        // 创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        
        System.out.println("--------统计集合中有几个以张开头的元素，并把统计个数在控制台输出--------");
        long count = list.stream().filter(s1 -> s1.startsWith("张")).count();
        System.out.println(count);
        
    }
    
}


    输出结果：

    --------统计集合中有几个以张开头的元素，并把统计个数在控制台输出--------
    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
25
26
6.6、案例 Collectors.toList ，Collectors.toMap
package fei.zhou.lambdalearn.demo6;

import javax.sound.midi.Soundbank;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo8 {
    
    public static void main(String[] args) {
        // 创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        
        System.out.println("--------得到名字为3个字的流，把流操作完毕的数据收集到List集合中并遍历--------");
        Stream<String> stream1 = list.stream().filter(s1 -> s1.length() == 3);
        
        List<String> collect = stream1.collect(Collectors.toList());
        collect.forEach(System.out::println);
        
        // 定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        String[] strArray = { "林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25" };
        
        System.out.println("--------得到字符串中年龄数据大于28的流--------");
        Stream.of(strArray).filter(s1 -> Integer.parseInt(s1.split(",")[1]) > 28).forEach(System.out::println);
        
        System.out.println("--------得到字符串中年龄数据大于28的流,把流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值--------");
        
        Stream<String> stream2 = Stream.of(strArray).filter(s1 -> Integer.parseInt(s1.split(",")[1]) > 28);
        
        Map<String, String> map = stream2.collect(Collectors.toMap(s1 -> s1.split(",")[0], s1 -> s1.split(",")[1]));
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key + "," + map.get(key));
        }
        
    }
    
}


    输出结果：

    --------得到名字为3个字的流，把流操作完毕的数据收集到List集合中并遍历--------
    林青霞
    张曼玉
    王祖贤
    张无忌
    --------得到字符串中年龄数据大于28的流--------
    林青霞,30
    张曼玉,35
    王祖贤,33
    --------得到字符串中年龄数据大于28的流,把流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值--------
    林青霞,30
    王祖贤,33
    张曼玉,35
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
6.7、案例
package fei.zhou.lambdalearn.demo6;

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

public class Demo9 {
    
    public static void main(String[] args) {
        // 现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作：
        // 1:男演员只要名字为3个字的前三人
        // 2:女演员只要姓林的，并且不要第一个
        // 3:把过滤后的男演员姓名和女演员姓名合并到一起
        // 4:把上一步操作后的元素作为构造方法的参数创建User对象,遍历数据
        // 创建集合
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");
        
        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");
        
        // 1:男演员只要名字为3个字的前三人
        Stream<String> stream1 = manList.stream().filter(s1 -> s1.length() == 3);
        
        // 2:女演员只要姓林的，并且不要第一个
        Stream<String> stream2 = womanList.stream().filter(s1 -> s1.startsWith("林")).skip(1);
        // 3:把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> concatStream = Stream.concat(stream1, stream2);
        // 4:把上一步操作后的元素作为构造方法的参数创建User对象,遍历数据
        concatStream.map(User::new).forEach(System.out::println);
        
    }
    
    /*
     * 演员类
     */
    public static class User {
        private String name;
        
        public User(String name) {
            this.name = name;
        }
        
        public String getName() {
            return name;
        }
        
        public void setName(String name) {
            this.name = name;
        }
        
        @Override
        public String toString() {
            return "User{" + "name='" + name + '\'' + '}';
        }
    }
    
}


    输出结果：

    User{name='周润发'}
    User{name='刘德华'}
    User{name='周星驰'}
    User{name='李连杰'}
    User{name='林青霞'}
    User{name='林志玲'}
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77