java8新特性Demo

蔚落 2023-07-07 08:50 5阅读 0赞

具体内容可以看下面这篇博客  
[java8新特性][java8]

package lambda;
    
    import org.junit.Test;
    
    import java.math.BigDecimal;
    import java.util.*;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    /** * @Description: * @Author: wuk * @CreateDate: 2020/3/20 11:04 * @UpdateDate: 2020/3/20 11:04 * @UpdateRemark: init * @Version: 1.0 * @menu */
    public class StreamDemo { 
    
    
        List<Person> list = new ArrayList<Person>() { { 
    
            add(new Person("a 1", 20, new BigDecimal(5000)));
            add(new Person("b 3", 25, new BigDecimal(6000)));
            add(new Person("c 4", 22, new BigDecimal(5000)));
            add(new Person("d 5", 26, new BigDecimal(2300)));
            add(new Person("e 6", 13, new BigDecimal(6500)));
            add(new Person("f 7", 65, new BigDecimal(4300)));
            add(new Person("h 8", 65, new BigDecimal(5700)));
            add(new Person("u 9", 5, new BigDecimal(7000)));
            add(new Person("a 2", 20, new BigDecimal(5000)));
        }};
    
        /** * 筛选与切片 */
    
        /** * filter-过滤 */
        @Test
        public void test01() { 
            list.stream()
                    .filter((person -> person.getAge() > 30))
                    .forEach(System.out::println);
        }
    
        /** * limit-限定元素数量 */
        @Test
        public void test02() { 
            list.stream()
                    .filter((person -> person.getAge() > 30))
                    .limit(2)
                    .forEach(System.out::println);
        }
    
        /** * skip-跳过元素 跳过前n个 * 注意：返回一个跳过前n个元素的流，若流中元素不足n个，则返回一个空流 */
        @Test
        public void test03() { 
            list.stream()
                    .filter((person -> person.getAge() > 30))
                    .skip(2)
                    .forEach(System.out::println);
        }
    
        /** * distinct-去重 * 注意：生成重写hashCode()和equals()方法 */
        @Test
        public void test04() { 
            list.stream()
                    .distinct()
                    .forEach(System.out::println);
        }
    
        /** * map映射 * map映射的重要应用为：即类似SQL中的映射，获取对象中的某些属性（即数据库中的某些字段） */
        @Test
        public void test06() { 
    
            //获取指定属性
            list.stream()
                    .map(Person::getName)
                    .forEach(System.out::println);
    
            //获取指定属性，并对属性进行操作
            list.stream()
                    .map(person -> person.getName().toUpperCase())
                    .forEach(System.out::println);
        }
    
    
        /** * flatMap映射 */
        @Test
        public void test07() { 
    
            //获取指定属性
            list.stream()
                    .map(person -> person.getName().split(" "))
                    .forEach(arr -> { 
                        System.out.println(Arrays.toString(arr));
                    });
    
    // 我们的目的是把 List 中每个字符串元素以" "分割开，变成一个新的 List。
    // 首先 map 方法分割每个字符串元素，但此时流的类型为 Stream<String[ ]>，
    // 因为 split 方法返回的是 String[ ] 类型；所以我们需要使用 flatMap 方法，
    // 先使用Arrays::stream将每个 String[ ] 元素变成一个 java.util.stream.Stream 流，
    // 然后 flatMap 会将每一个流连接成为一个流，最终返回我们需要的 Stream
            list.stream()
                    .map(person -> person.getName().split(" "))
                    .flatMap(Arrays::stream)
                    .forEach(System.out::println);
        }
    
        /** * 自然排序 sorted() * 自然排序(Comparable方式)，按照字典顺序进行排序 * reversed() 倒序 从大到小 * 优先排序的元素放在后面 */
        @Test
        public void test08() { 
            //获取指定属性
            list.stream()
                    .sorted(Comparator.comparing(Person::getAge).reversed())
                    .sorted(Comparator.comparing(Person::getSalary))
                    .forEach(System.out::println);
        }
    
        /** * allMatch-检查是否匹配所有元素 * 返回结果： * - true 匹配到了所有的元素 注意：和noneMatch()的false 结果代表集合不同 * - false 没有匹配到所有的元素 说明匹配到条件集合中的真子集 */
        @Test
        public void test09() { 
            //获取指定属性
            boolean b = list.stream()
                    .allMatch(person -> person.getAge() > 4);
            System.out.println(b);
        }
    
        /** * anyMatch-检查是否至少匹配一个元素 * 返回结果： * - true 匹配到了条件集合中的真子集元素，一个或者多个 * - false 一个元素都没有匹配到，空集 */
        @Test
        public void test10() { 
            //获取指定属性
            boolean b = list.stream()
                    .anyMatch(person -> person.getAge() > 60);
            System.out.println(b);
        }
    
        /** * noneMatch-检查是否所有元素都没有匹配到 * 返回结果： * - true 所有元素都没有匹配到，空集 * - false 不是所有的元素都没有匹配到 即匹配到了元素,有匹配到的元素即返回false，真子集 */
        @Test
        public void test11() { 
            //获取指定属性
            boolean b = list.stream()
                    .noneMatch(person -> person.getAge() > 90);
            System.out.println(b);
        }
    
    
        /** * count-返回流中元素总个数 */
        @Test
        public void test12() { 
            long size = list.stream().count();
            System.out.println(size);
        }
    
        /** * min-返回流中的最小值 * 注意 与当前的排序顺序有关系 */
        @Test
        public void test13() { 
    
            Person person = list.stream().max(Comparator.comparing(Person::getAge)).get();
            System.out.println(person);
    
            Person person1 = list.stream().min(Comparator.comparing(Person::getAge)).get();
            System.out.println(person1);
        }
    
        /** * reduce-将流中元素反复结合起来，得到一个值 */
        @Test
        public void test15() { 
    
            List<Integer> asList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
            //利用reduce归约函数，可以指定归约规则，将集合中的元素数值进行求和操作等
            //以0为起始值，对集合中的各个值进行相加
            Integer sum = asList.stream().reduce(0, (x, y) -> x + y);
            //等价于
            Integer sum1 = asList.stream().reduce(0, Integer::sum);
            System.out.println(sum);
    
            //以1为起始值
            Integer sum2 = asList.stream().reduce(1, (x, y) -> x * y);
            System.out.println(sum2);
    
            //对象中的属性值 属性类型是基本类型
            Optional<Integer> reduce = list.stream().map(Person::getAge).reduce(Integer::sum);
            System.out.println("age = " + reduce.get());
    
            //对象中的属性值 属性类型是其他类型
            BigDecimal reduce1 = list.stream().map(Person::getSalary).reduce(BigDecimal.ZERO, BigDecimal::add);
            System.out.println("salary= " + reduce1);
    
        }
    
        /** * collect-将流转换为其他形式 */
        @Test
        public void test16() { 
    
            List<String> names = list.stream().map(Person::getName).collect(Collectors.toList());
            System.out.println(names);
        }
    
        /** * Collectors类中的常用方法 */
        /** * counting-统计数量 */
        @Test
        public void test17() { 
    
            Long size = list.stream().collect(Collectors.counting());
            System.out.println(size);
        }
    
    
        /** * averagingInt-求平均值并转换成Double类型 */
        @Test
        public void test18() { 
    
            Double averInt = list.stream()
                    .collect(Collectors.averagingInt(Person::getAge));
            System.out.println(averInt);
            Double averDouble = list.stream()
                    .collect(Collectors.averagingDouble(Person::getAge));
            System.out.println(averDouble);
        }
    
        /** * summingDouble-求和并转换成Double类型 */
        @Test
        public void test19() { 
    
            Double mapToDouble = list.stream().mapToDouble(Person::getAge).sum();
            Double summingDouble = list.stream()
                    .collect(Collectors.summingDouble(Person::getAge));
            System.out.println(summingDouble);
            Integer summingInt = list.stream()
                    .collect(Collectors.summingInt(Person::getAge));
            System.out.println(summingInt);
    
        }
    }

[java8]: https://blog.csdn.net/hxhaaj/article/details/80725857?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task