JDK8之lambda表达式

1/**
2 *JDK8  Stream特性
3 * Created by chengbx on 2018/5/27.
4 * Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、
5 * 高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。
6 * Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。
7 * 同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，
8 * 使用 fork/join 并行方式来拆分任务和加速处理过程。
9 * 通常编写并行代码很难而且容易出错，但使用 Stream API 无需编写一行多线程的代码，
10 * 就可以很方便地写出高性能的并发程序。
11 * 所以说，Java 8 中首次出现的 java.util.stream 是一个函数式语言+多核时代综合影响的产物。
12 *  一、Stream API 的操作步骤：
13 *        
14 * 1. 创建 Stream
15 *
16 * 2. 中间操作
17 *
18 * 3. 终止操作(终端操作)
19 *
20 * 4.   接口中的默认方法
21 *      接口默认方法的”类优先”原则
22 *      若一个接口中定义了一个默认方法，而另外一个父类或接口中
23 *      又定义了一个同名的方法时
24 *      1.选择父类中的方法。如果一个父类提供了具体的实现，那么
25 *      接口中具有相同名称和参数的默认方法会被忽略.
26 *      2.接口冲突。如果一个父接口提供一个默认方法，而另一个接
27 *      口也提供了一个具有相同名称和参数列表的方法（不管方法
28 *      是否是默认方法），那么必须覆盖该方法来解决冲突
29 * 5.   新增的重复注解@Repeatble和类型注解
30 *         java8新增了重复注解，其使用方式为：
31             @Repeatable(Authorities.class)
32             public @interface Authority {
33                String role();
34             }
35             public @interface Authorities {
36                Authority[] value();
37             }
38             public class RepeatAnnotationUseNewVersion {
39                 @Authority(role="Admin")
40                 @Authority(role="Manager")
41                 publicvoiddoSomeThing(){ }
42             }
43      2.Java8为ElementType枚举增加了TYPE_PARAMETER、TYPE_USE两个枚举值，
44             从而可以使用@Target(ElementType_TYPE_USE)修饰注解定义，这种注解被称为类型注解，
45             可以用在任何使用到类型的地方
46 */
47public class TestStream {
48
49    List<Employee> employees = Arrays.asList(
50            new Employee("aaa",11,5000),
51            new Employee("bbb",21,5200),
52            new Employee("ccc",13,5500),
53            new Employee("ddd",54,6400),
54            new Employee("eee",16,7100),
55            new Employee("fff",74,7120),
56            new Employee("ggg",12,7150)
57    );
58    /**
59     * 创建stream
60     */
61    @Test
62    public void test1(){
63        //1. Collection 提供了两个方法  stream() 与 parallelStream()
64        List<String> list = new ArrayList<>();
65        Stream<String> stream =  list.stream();
66        Stream<String> parallelStream = list.parallelStream(); //获取一个并行流
67        //2. 通过 Arrays 中的 stream() 获取一个数组流
68        Integer[] nums = new Integer[10];
69        Stream<Integer> stream1 = Arrays.stream(nums);
70        //3. 通过 Stream 类中静态方法 of()
71        Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);
72        //4. 创建无限流
73        //迭代
74        Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
75        stream3.forEach(System.out::println);
76
77        //生成
78        Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
79        stream4.forEach(System.out::println);
80    }
81    /*
82      筛选与切片
83        filter——接收 Lambda ， 从流中排除某些元素。
84        limit——截断流，使其元素不超过给定数量。
85        skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，
86        则返回一个空流。与 limit(n) 互补
87        distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
88     */
89    //内部迭代：迭代操作 Stream API 内部完成
90    @Test
91    public void test2(){
92        //中间操作,不会执行任何操作
93        Stream<Employee> str = employees.stream().filter((e) -> e.getAge()>30).limit(1);
94        //终止操作,一次性执行全部内容，即"惰性求值"
95        str.forEach(System.out::println);
96        // employees.stream().filter((e) -> e.getAge()<30)
97        //            .forEach((employee) -> System.out.println(employee));
98    }
99    //外部迭代
100    @Test
101    public void test3(){
102        Iterator<Employee> it = employees.iterator();
103        while(it.hasNext()){
104            System.out.println(it.next());
105        }
106    }
107    @Test
108    public void test4(){
109        employees.stream()
110                .filter((e) -> {
111                    System.out.println("短路！"); // &&  ||
112                    return e.getSalary() >= 5000;
113                }).limit(3)
114                .forEach(System.out::println);
115    }
116
117    @Test
118    public void test5(){
119        employees.parallelStream()
120                .filter((e) -> e.getSalary() >= 5000)
121                .skip(2)
122                .forEach(System.out::println);
123    }
124    @Test
125    public void test6(){
126        employees.stream()
127                .distinct()
128                .forEach(System.out::println);
129    }
130
131    /**
132     * 映射
133     * map -接收lambda，将元素转换成其他形式获取信息，接收一个函数作为参数，
134            该函数会被应用在每个元素上，并将其映射成一个新的元素。
135     * flatmap-接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
136     */
137    @Test
138    public void test7(){
139        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
140        list.stream().map((str) -> str.toUpperCase())
141                     .forEach((str) -> System.out.println(str));
142        System.out.println("---------------");
143        employees.stream().map(Employee::getName)
144                 .forEach((name) ->System.out.println(name));
145    }
146    /**
147     * 排序
148     * sorted()--自然排序(comparable)
149     * sorted(Comparator com)--定制排序(Comparator)
150     */
151    @Test
152    public void test8(){
153        List<String> list = Arrays.asList("eee","ggg","ccc","ddd");
154        list.stream().sorted().forEach(System.out::println);
155        System.out.println("-------------------以下是定制排序-------------");
156        employees.stream().sorted((e1,e2) ->{
157            if (e1.getAge() ==e2.getAge()) {
158                return e1.getName().compareTo(e2.getName());
159            }else{
160                return Integer.compare(e1.getAge(),e2.getAge());
161            }
162        }).forEach((employee) -> System.out.println(employee));
163    }
164    //3. 终止操作
165    /*
166        allMatch——检查是否匹配所有元素
167        anyMatch——检查是否至少匹配一个元素
168        noneMatch——检查是否没有匹配的元素
169        findFirst——返回第一个元素
170        findAny——返回当前流中的任意元素
171        count——返回流中元素的总个数
172        max——返回流中最大值
173        min——返回流中最小值
174        注意：流进行了终止操作后，不能再次使用
175     */
176
177    @Test
178    public void test9(){
179        boolean b = employees.stream().allMatch((emp) -> emp.getAge()==15);
180        System.out.println(b);
181        System.out.println("---------------");
182        boolean b1 = employees.stream().anyMatch((emp) -> emp.getAge()==15);
183        System.out.println(b1);
184        System.out.println("---------------");
185        boolean b2 = employees.stream().noneMatch((emp) -> emp.getAge()==15);
186        System.out.println(b2);
187        System.out.println("---------------");
188        Optional<Employee> optional = employees.stream()
189                .sorted((emp1, emp2) -> Double.compare(emp1.getSalary(),emp2.getSalary()))
190                .findFirst();
191        System.out.println(optional.get());
192        System.out.println("---------------");
193        Optional<Employee> optional1 = employees.parallelStream()
194                                                .filter((emp) -> emp.getAge() >15).findAny();
195        System.out.println(optional1);
196        System.out.println("---------------");
197        Long count = employees.parallelStream().filter((emp) -> emp.getAge() >15).count();
198        System.out.println(count);
199        Optional<Double> optiona3 = employees.stream()
200                                             .map((emp) -> emp.getSalary()).max(Double::compareTo);
201        System.out.println(optiona3.get());
202        System.out.println("---------------");
203        Optional<Employee> optiona4 = employees.stream()
204                                               .min((e1,e2) ->Double.compare(e1.getSalary(),e2.getSalary()));
205        System.out.println(optiona4);
206    }
207
208    /**
209     * 归约
210     reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。
211     */
212    @Test
213    public void test10(){
214        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
215        Integer sum = list.stream().reduce(0,(x,y) -> x+y);
216        System.out.println(sum);//55
217        System.out.println("---------------------");
218        Optional<Double> sumSal = employees.stream().map(Employee::getSalary).reduce(Double::sum);
219        System.out.println(sumSal);
220    }
221    /**
222     * 收集:
223     * collect——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
224     */
225    //将employee集合中name值取出来放入集合中 aaa bbb ccc ddd eee fff ggg
226    @Test
227    public void test11(){
228        List list = employees.stream().map(Employee::getName).collect(Collectors.toList());
229        list.forEach(System.out::println);
230    }
231    @Test
232    public void test12(){
233        Set set = employees.stream().map(Employee::getName).collect(Collectors.toSet());
234        set.forEach(System.out::println);
235    }
236    @Test
237    public void test13(){
238        HashSet hashSet = employees.stream().map(Employee::getName)
239                                   .collect(Collectors.toCollection(HashSet::new));
240        hashSet.forEach(System.out::println);
241    }
242    //获取集合中元素的个数  7
243    @Test
244    public void test14(){
245        long count =  employees.stream().collect(Collectors.counting());
246        System.out.println(count);
247        System.out.println("----------------");
248        //获取工资平均值
249        Double avgMoney = employees.stream()
250                                   .collect(Collectors.averagingDouble((emp) -> emp.getSalary()));
251        System.out.println(avgMoney);//6210.0
252        System.out.println("----------------");
253        //工资总和
254        Double sumMoney = employees.stream()
255                                   .collect(Collectors.summingDouble(Employee::getSalary));
256        System.out.println(sumMoney);
257        //最大值
258        Optional<Employee> optional= employees.stream()
259                .collect(Collectors.maxBy((emp1,emp2) -> Double.compare(emp1.getSalary(),emp2.getSalary())));
260        System.out.println(optional.get());//Employee{name='ggg', age=12, salary=7150.0}
261        //最小值
262        Optional<Double> minMoney = employees.stream()
263                        .map(Employee::getSalary).collect(Collectors.minBy(Double::compare));
264        System.out.println(minMoney.get());
265    }
266    //分组
267    @Test
268    public void test15(){
269                employees.stream()
270                .collect(Collectors.groupingBy(Employee::getAge));
271    }
272    //分区
273    @Test
274    public  void test16(){
275       Map<Boolean,List<Employee>> map =employees.stream()
276                                        .collect(Collectors.partitioningBy((e) -> e.getSalary() >6000));
277        System.out.println(map);
278        //{false=[Employee{name='aaa', age=11, salary=5000.0}, Employee{name='bbb', age=21, salary=5200.0},
279        // Employee{name='ccc', age=13, salary=5500.0}],
280        // true=[Employee{name='ddd', age=54, salary=6400.0}, Employee{name='eee', age=16, salary=7100.0},
281        // Employee{name='fff', age=74, salary=7120.0}, Employee{name='ggg', age=12, salary=7150.0}]}
282
283    }
284
285    @Test
286    public void test17(){
287        DoubleSummaryStatistics dss =employees.stream()
288                                              .collect(Collectors.summarizingDouble(Employee::getSalary));
289        //求平均值
290        System.out.println(dss.getAverage());
291        //求最大值
292        System.out.println(dss.getMax());
293        //求和
294        System.out.println(dss.getSum());
295    }    @Test
296    public void test18(){
297        String name = employees.stream().map(Employee::getName).collect(Collectors.joining(","));
298        System.out.println(name);//aaa,bbb,ccc,ddd,eee,fff,ggg
299    }
300}