Java stream

发表于 分类于
Java 的流

stream

老是打成 steam 哈哈哈（不是

主要针对集合或数组

https://www.runoob.com/java/java8-streams.html

简化集合或数组api的弊端

整成链式编程

常用api

  • forEach：逐一遍历
  • count：统计个数
  • filter：过滤元素 就是匿名内部类Predicate，符合返回true
  • limit：取前几个元素
  • skip：跳过前几个
  • map：加工方法
  • concat：合并流

终结方法：

  • forEach
  • count

非终结方法：

  • 每次调用返回 Stream 对象

收集 Stream 流：

  • 把流的数据转成集合
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/**
 * Created by KebabShell
 * on 2020/4/8 下午 04:03
 */
public class StreamTest {
    @Test
    public void test0(){
        List<String> list = new ArrayList<>();

        list.add("dd");
        list.add("dwe");
        list.add("dwq");
        list.add("qd");
        list.add("rd");

        //找出开头为d的
        List<String> list_d = new ArrayList<>();
        for (String s :
             list) {
            if (s.startsWith("d")){
                list_d.add(s);
            }
        }
        System.out.println(list_d);
        //找出开头为d的，长度为3的
        List<String> list_d_3 = new ArrayList<>();
        for (String s :
             list_d) {
            if (s.length() == 3){
                list_d_3.add(s);
            }
        }
        System.out.println(list_d_3);

        /**
         * stream
         *
         * 淦，牛逼
         */

        list.stream()
            .filter(s -> s.startsWith("d"))
            .filter(s -> s.length() == 3)
            .forEach(System.out::println);

        /**
         * count
         */
        long count = list.stream().count();
        System.out.println(count);

        /**
         * limit  拿前两个
         */
        list.stream()
            .filter(s -> s.length() == 3)
            .limit(2)
            .forEach(System.out::println);
        /**
         * skip  不要前两个
         */
        list.stream()
            .filter(s -> s.length() == 3)
            .skip(2)
            .forEach(System.out::println);

        /**
         * 在后面加上123
         */
        list.stream().map(s -> s + "123").forEach(System.out::println);
        /**
         * 转成其他对象
         */
        list.stream().map(s -> new StreamPerson(s)).forEach(System.out::println);
        //---->
        list.stream().map(StreamPerson::new).forEach(System.out::println);

        /**
         * 合并流
         */
        Stream<Integer> s1 = Stream.of(1, 4, 3);
        Stream<String> s2 = list.stream();
        Stream<Object> s1s2 = Stream.concat(s1, s2);
        s1s2.forEach(System.out::println);


        /**
         * 把流转为集合
         */
        Stream<String> stream = list.stream()
            .filter(s -> s.startsWith("d"))
            .filter(s -> s.length() == 3);
        Set<String> collect = stream.collect(Collectors.toSet());
        /**
         * 转List
         */
        Stream<String> stream1 = list.stream()
            .filter(s -> s.startsWith("d"))
            .filter(s -> s.length() == 3);//不加这句的话会报错，现在需要重新创建流
        List<String> collect1 = stream1.collect(Collectors.toList());
        /**
         * 转数组
         */
        Stream<String> stream2 = list.stream()
            .filter(s -> s.startsWith("d"))
            .filter(s -> s.length() == 3);
        Object[] objects = stream2.toArray();
        //构造器引用
        String[] strings = stream2.toArray(String[]::new);
    }

    public static void main(String[] args) {
        /**
         * Collection获取流
         */
        Collection<String> c = new ArrayList<>();

        Stream<String> c_s = c.stream();

        /**
         * Map集合获取流
         */
        Map<String, Integer> map = new HashMap<>();

        Stream<String> k_s = map.keySet().stream();
        Stream<Integer> v_s = map.values().stream();
        Stream<Map.Entry<String, Integer>> m_s = map.entrySet().stream();

        /**
         * 数组获取流
         */
        String[] strings = {"ad", "dag", "dageae", "vcz"};
        Stream<String> s_s = Arrays.stream(strings);
        Stream<String> s_s2 = Stream.of(strings);


    }
}