【Java】Java开发中你需要掌握的Lambda表达式_java lamda 表达式 group-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_64210833/article/details/142876929

Lambda表达式是Java 8引入的一种新的语法结构，用于简化匿名内部类的编写。它主要用于函数式编程，使代码更加简洁和易读。Lambda表达式的主要作用是提供一种简洁的方式来定义和传递函数式接口的实例。

8.使用Lambda表达式进行Optional的创建

9.使用Lambda表达式进行stream流操作

10.使用Lambda表达式进行函数式接口的实现

1.使用Lambda表达式对集合进行遍历

         List<Integer> integerList = Arrays.asList(2, 21, 6, 5);
        /**
         * 1.对集合进行遍历
         * */
        // 1.1未使用Lambda表达式进行遍历
        integerList.forEach(System.out::println);
        for (Integer s : integerList) {
            System.out.println(s);
        }
        // 1.2使用Lambda表达式进行遍历
        integerList.forEach(s -> System.out.println(s));

2.使用Lambda表达式对集合进行排序

        /**
         * 2.对集合进行排序
         * */
        // 2.1未使用Lambda表达式进行排序
        integerList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });

        Collections.sort(integerList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });
        // 2.2使用Lambda表达式进行排序
        integerList.sort((o1, o2) -> o1.compareTo(o2));
        Collections.sort(integerList, (o1, o2) -> o1.compareTo(o2));
        // 测试结果
        integerList.forEach(s -> System.out.println(s));

3.使用Lambda表达式对集合进行过滤

        /**
         * 3.对集合进行过滤
         * */
        // 3.1未使用Lambda表达式进行过滤
        List<Integer> filterList = new ArrayList<>();
        for (Integer i : integerList) {
            if (i > 10) {
                filterList.add(i);
            }

        }
        // 3.2使用Lambda表达式进行过滤
        filterList = integerList.stream().filter(i -> i > 10).collect(Collectors.toList());
        // 测试结果
        filterList.forEach(s -> System.out.println(s));

4.使用Lambda表达式对集合进行映射

        /**
         * 4.对集合进行映射
         * */
        // 4.1未使用Lambda表达式进行映射
        List<Integer> mapList = new ArrayList<>();
        for (Integer i : integerList) {
            mapList.add(i + 1);
        }
        // 4.2使用Lambda表达式进行映射
        mapList = integerList.stream().map(i -> i + 1).collect(Collectors.toList());
        // 测试结果
        mapList.forEach(s -> System.out.println(s));

5.使用Lambda表达式对集合进行求和

        /**
         * 5.对集合进行求和
         * */
        // 5.1未使用Lambda表达式进行求和
        int sum = 0;
        for (Integer i : integerList) {
            sum += i;
        }
        // 5.2使用Lambda表达式进行求和
        sum = integerList.stream().reduce(0, (a, b) -> a + b);
        // 测试结果
        System.out.println(sum);

6.使用Lambda表达式对集合进行分组

         /**
         * 6.对集合进行分组
         * */
        // 6.1未使用Lambda表达式进行分组
        Map<Boolean, List<Integer>> groupMap = new HashMap<>();
        for (Integer i : integerList) {
            boolean isEven = (i % 2 == 0);
            // 获取或创建一个新的List
            List<Integer> list = groupMap.get(isEven);
            // 如果list为null，则创建一个新的List并将其添加到groupMap中
            if (list == null) {
                list = new ArrayList<>();
                groupMap.put(isEven, list);
            }
            // 将i添加到list中
            list.add(i);
        }
        // 6.2使用Lambda表达式进行分组
        for (Integer i : integerList) {
            boolean isEven = (i % 2 == 0);
            groupMap.computeIfAbsent(isEven, k -> new ArrayList<>()).add(i);
        }
        // 测试结果
        groupMap.forEach((k, v) -> System.out.println(k + ":" + v));

7.使用Lambda表达式进行线程的创建

        /**
         * 7.进行线程的创建
         * */
        // 7.1未使用Lambda表达式进行线程的创建
        Thread thread = new Thread(() -> {
            System.out.println("Hello World!");
        });
        thread.start();
        // 7.2使用Lambda表达式进行线程的创建
        Thread thread1 = new Thread(() -> System.out.println("Hello Lambda!"), "MyThread");
        thread1.start();

8.使用Lambda表达式进行Optional的创建

        /**
         * 8.进行Optional的创建
         * optional的作用：Optional类是一个容器，可以用来存储任意类型的对象，并且可以保证在对象为空的情况下不会抛出NullPointerException异常。
         * */
        // 8.1未使用Lambda表达式进行Optional的创建
        String str = "hello";
        Optional<String> optional = Optional.ofNullable(str);
        // 如果optional不为空，则输出它的值
        if (optional.isPresent()) {
            System.out.println(optional.get());
        }
        // 8.2使用Lambda表达式进行Optional的创建
        Optional<String> optional1 = Optional.of(Optional.ofNullable(str).orElseGet(() -> "defaultValue"));
        // 如果optional不为空，则输出它的值
        optional1.ifPresent(System.out::println);

9.使用Lambda表达式进行stream流操作

        /**
         * 9.进行stream流操作
         * */
        List<String> stringList = Arrays.asList("aaaac", "bbbbc", "cccccd");
        // 9.1未使用Lambda表达式进行stream流操作
        List<String> streamList = new ArrayList<>();
        for (String s : stringList) {
            if(s.endsWith("d")){
                streamList.add(s.toUpperCase());
            }
        }
        for (String s : streamList) {
            System.out.println(s);
        }

        // 9.2使用Lambda表达式进行stream流操作
        stringList.stream().filter(s -> s.endsWith("d")).map(String::toUpperCase).forEach(System.out::println);

10.使用Lambda表达式进行函数式接口的实现

        /**
         * 10.进行函数式接口的实现
         * */
        // 10.1未使用Lambda表达式进行函数式接口的实现
        public interface MyFunction {
            void getValue(String i);
        }

        MyFunction myFunction = new MyFunction() {
            @Override
            public void getValue(String i) {
                 System.out.println(i);
            }
        };
        myFunction.getValue("123");

        // 10.2使用Lambda表达式进行函数式接口的实现
        MyFunction myFunction1 = i -> System.out.println(i);
        myFunction1.getValue("123");

如果觉得上述对你有帮助，也可以到我的主页看看，说不定有你喜欢的文章。