java8新特性Demo

具体内容可以看下面这篇博客
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);

    }
}