Lambda&Stream&Optional

/**
 * @Author LWL
 * @Date 2022/4/10 14:25
 * @TODO Lambda
 */
public class Test {
    public static void main(String[] args) {

        /**
         * Lambda 表达式是一个匿名函数,可以理解为一段可传递的代码
         * 1) 优点：简化了匿名内部类的使用,语法更简单
         * 2) 格式：(参数类型 参数名) -> {方法体}
         * 3) 接口中必须只有一个抽象方法
         *
         * 【Lambda 表达式使用前提】
         * 1) 方法的参数或局部变量类型必须为接口
         * 2) 接口中只有一个抽象方法 @FunctionalInterface
         *
         * 【匿名内部类和Lambda对比】
         *  1) 所需参数不一样,匿名内部类的参数可以是类、抽象类、接口 ,Lambda表达式所需要的类型必须是接口，而且只能有一个
         */
        //普通写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();

        //lambda写法
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName());
        }).start();
    }

/**
 * @Author LWL
 * @Date 2022/4/10 14:52
 * @TODO
 */
public class NoParameterTest {
    public static void main(String[] args) {

        //无参
        /*@FunctionalInterface  
        //@FunctionalInterface这是一个标志注解,被该注解修饰的接口，只能声明一个抽象方法
        public interface NoParameterService {
            public abstract void show();
        }*/

        getShow(new NoParameterService() {
            @Override
            public void show() {
                System.out.println("show() 方法1");
            }
        });

        //lambda {} 可去掉
        getShow(() -> System.out.println("show() 方法2"));
    }

    public static void getShow(NoParameterService noParameterService){
        noParameterService.show();
    }

/**
 * @Author LWL
 * @Date 2022/4/10 15:06
 * @TODO 含参
 */
public class ContParameterTest {
    public static void main(String[] args) {

        ArrayList<Person> list = new ArrayList<>();
        PersonList(list);
        Collections.sort(list,(x,y) -> x.getScore().compareTo(y.getScore()));

    }

    public static void PersonList(ArrayList<Person> list) {
        list.add(new Person("A", 01, 100));
        list.add(new Person("B", 02, 600));
        list.add(new Person("C", 03, 300));
        list.add(new Person("D", 04, 200));
        list.add(new Person("E", 05, 500));
    }

/**
 * @Author LWL
 * @Date 2022/4/9 21:59
 * @TODO Stream 流
 */

public class Test {
    public static void main(String[] args) {

        ArrayList<User> userList = new ArrayList<>();
        userList.add(new User("E", 5, "男"));
        userList.add(new User("A", 10, "女"));
        userList.add(new User("B", 20, "男"));
        userList.add(new User("C", 15, "女"));
        userList.add(new User("D", 25, "男"));
        userList.add(new User("F", 30, "女"));

        //过滤
        userList.stream().filter(x -> x.getAge() > 10).map(User::getEmplyNm).collect(Collectors.toList());
        //匹配第一个值
        userList.stream().filter(x -> x.getAge() > 10).findFirst().get();
        userList.stream().filter(x -> x.getAge() > 10).limit(1).collect(Collectors.toList());
        //最大值
        userList.stream().max(Comparator.comparing(User::getAge)).map(User::getAge).get();
        //最小值
        userList.stream().min(Comparator.comparing(User::getAge)).map(User::getAge).get();
        /*----------------------------------------------------------------------------------*/
        List<String> strArray = Arrays.asList("A", "AB", "ABC", "ABCD");
        //获取最长字符
        strArray.stream().max(Comparator.comparing(String::length)).get();
        /*----------------------------------------------------------------------------------*/
        List<Integer> intArray = Arrays.asList(10, 20, 30, 40, 50);
        //最大值
        intArray.stream().max((x, y) -> x.compareTo(y)).get();
        /*----------------------------------------------------------------------------------*/
        String[] strArrays = {"a", "ab", "abc", "abed", "abide"};
        //转大小写
        Arrays.stream(strArrays).map(x -> x.toUpperCase(Locale.ROOT)).collect(Collectors.toList());
        Arrays.stream(strArrays).map(String::toUpperCase).collect(Collectors.toList());
        /*----------------------------------------------------------------------------------*/
        List<Integer> numArray = Arrays.asList(9, 19, 29, 39, 49);
        //整体 +1
        numArray.stream().map(x -> x + 1).collect(Collectors.toList());
        //不改变
        userList.stream().map(x -> {
            User user = new User().setAge(x.getAge() + 100);
            return user;
        }).collect(Collectors.toList());
        //改变
        userList.stream().map(x -> {
            x.setAge(x.getAge() + 100);
            return x;
        }).collect(Collectors.toList());
        /*----------------------------------------------------------------------------------*/
        //字符分割操作
        List<String> strData = Arrays.asList("a,b,c,d", "e,f,g,h");
        /*[a, b, c, d, e, f, g, h]*/
        strData.stream().flatMap(x -> {
            String[] split = x.split(",");
            Stream<String> stream = Arrays.stream(split);
            return stream;
        }).collect(Collectors.toList());
        /*----------------------------------------------------------------------------------*/
        /** 求和 */
        List<Integer> noArray = Arrays.asList(10, 20, 30, 40, 50);
        // 一
        noArray.stream().reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        }).get();
        //二
        noArray.stream().reduce((x, y) -> x + y).get();
        //三
        noArray.stream().reduce(0, Integer::sum);
        //乘积
        noArray.stream().reduce((x, y) -> x * y).get();
        //求最大值
        Integer integer = noArray.stream().reduce((x, y) -> x > y ? x : y).get();
        Integer reduce = noArray.stream().reduce(0, Integer::max);

        //求和 & 最大数值
        ArrayList<Person> list = CollectionUtil.newArrayList();
        list.add(new Person("A", 01, 100));
        list.add(new Person("B", 02, 200));
        list.add(new Person("C", 03, 300));
        list.add(new Person("D", 04, 400));
        list.add(new Person("E", 05, 500));

        //求 score 之和
        list.stream().map(Person::getScore).reduce((x, y) -> x + y).get();
        list.stream().map(Person::getScore).reduce(Integer::sum).get();
        //求最高数值
        list.stream().map(Person::getScore).reduce((x, y) -> x > y ? x : y).get();
        list.stream().map(Person::getScore).reduce(Integer::max).get();

        /*----------------------------------------------------------------------------------*/
        /** 接合 */
        //接合可以将Stream中的元素用特定的连接符(没有直接连接)链接成一个字符串
        String collect = list.stream().map(Person::getEmplyNm).collect(Collectors.joining(","));
        /*----------------------------------------------------------------------------------*/
        /** 排序 */
        List<Integer> soreArray = Arrays.asList(20, 30, 10, 50, 40);
        //升序
        soreArray.stream().sorted().collect(Collectors.toList());
        soreArray.stream().sorted(Comparator.comparing(x -> x)).collect(Collectors.toList());
        //降序
        soreArray.stream().sorted(Comparator.comparing(x -> x.toString()).reversed()).collect(Collectors.toList());
        /*----------------------------------------------------------------------------------*/
        /**提取、组合*/
        //流 合并、去重、限制、跳过
        String[] array1 = {"a", "b", "c", "e"};
        String[] array2 = {"a", "b", "f", "g"};

        Stream<String> array11 = Stream.of(array1);
        Stream<String> array22 = Arrays.stream(array2);

        // concat 合并流 去重
        Stream.concat(array11, array22).collect(Collectors.toSet());
        Stream.concat(array11, array22).distinct().collect(Collectors.toList());
        // limit 限制获取的数据
        Stream.iterate(1, x -> x + 2).limit(3).collect(Collectors.toList());
        // skip 跳过前n数据
        Stream.iterate(1, x -> x + 2).skip(1).limit(3).collect(Collectors.toList());


    }
}

/**
 * @Author LWL
 * @Date 2022/4/10 3:42
 * @TODO Optional
 */
public class Test {
    public static void main(String[] args) {

        /**
         * Optional 是一个被final修饰没有子类的工具类，是一个可以为null的容器对象
         * 1)防止空指针异常
         * 2)简化if else代码
         *
         * 【Optional 对象创建方式】
         * 1)通过 of 方法，该方法不支持null
         * 2)通过 ofNullable 方法，支持null
         * 3)通过 empty 方法直接创建一个空的Optional对象
         *
         *  【判断】
         * 1) isPresent() 判断是否包含之，包含值返回true，不包含返回false
         * 2) ifPresent(Consumer c)：如果optional不为空，则将optional中的对象传给Comsumer函数
         * 3) orElse(T t) 如果调用对象包含值，则返回，否则返回t
         * 4) orElseGet(Supplier s) 如果optional不为空，则返回optional中的对象；如果为null，则使用Supplier函数生成默认值other
         * 5) orElseThrow(Supplier<X> exception)：如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常
         *
         *  【过滤】
         * 1) filter(Predicate<T> p)：如果optional不为空，则执行断言函数p，如果p的结果为true，则返回原本的optional，否则返回空的optional
         *
         *  【映射】
         *  1) map(Function<T, U> mapper)：如果optional不为空，则将optional中的对象 t 映射成另外一个对象 u，并将 u 存放到一个新的optional容器中。
         *  2) flatMap(Function< T,Optional<U>> mapper)：跟上面一样，在optional不为空的情况下，将对象t映射成另外一个optional
         *  区别：map会自动将u放到optional中，而flatMap则需要手动给u创建一个optional
         *
         */


        // 1)
        Optional<String> op1 = Optional.of("A");
        // 2)
        Optional<String> op2 = Optional.ofNullable("A");
        Optional<Object> op3 = Optional.ofNullable(null);
        // 3)
        Optional<Object> op4 = Optional.empty();

        Object o = op4.orElseGet(() -> {
            return "hello";
        });

        op1.ifPresent(x -> System.out.println(x));
        op1.ifPresent(System.out::println);

        Person person = new Person().setEmplyNm("abc").setEmplyNo(01).setScore(100);
        String name = getName(Optional.ofNullable(person));
        System.out.println(name);

    }

    //普通写法
    public static String getName(Person person) {
        if (ObjectUtil.isNotNull(person)) {
            if (StrUtil.isNotEmpty(person.getEmplyNm())) {
                return person.getEmplyNm().toUpperCase(Locale.ROOT);
            } else {
                return null;
            }
        } else {
            return null;
        }
    }

    //Optional
    public static String getName(Optional<Person> person) {
        if (person.isPresent()) {
            return person.map(Person::getEmplyNm)
                    .map(String::toUpperCase)
                    .orElse(null);
        }
        return null;
    }
}