Java8 Lambda表达式学习

向右看齐 2023-10-04 11:11 6阅读 0赞

### Java8 Lambda表达式学习 ###

**一、Lambda演变：**  
1.函数式接口：只包含一个抽象方法的接口  
2.接口实现：

外部类实现
    静态内部类实现
    局部内部类实现
    匿名内部类实现
    Lambda实现

3.Lambda表达式不能修改在方法外定义的变量，即只能引用后则该变量默认使用final修饰  
4.代码演示：

package com.atguigu.util;
    
    /**
     * Description: Lambda测试
     *
     * @Author: zhx & moon hongxu_1234@163.com
     * @Date: 2021-04-17 18:05
     * @version: V1.0.0
     */
    public class LambdaTest {
        
    
        /**
         * 静态内部类
         */
        static class Like2 implements ILikeMoon {
        
            @Override
            public void print() {
        
                System.out.println("我是函数式接口-静态内部类实现");
            }
        }
    
        public static void main(String[] args) {
        
    
            Like like = new Like();
            like.print();
    
            Like2 like2 = new Like2();
            like2.print();
    
            /**
             * 局部内部类
             */
            class Like3 implements ILikeMoon{
        
                @Override
                public void print() {
        
                    System.out.println("我是函数式接口-局部内部类实现");
                }
            }
            Like3 like3 = new Like3();
            like3.print();
    
            /**
             * 匿名内部类
             */
            ILikeMoon like4 = new ILikeMoon() {
        
                @Override
                public void print() {
        
                    System.out.println("我是函数式接口-匿名内部类实现");
                }
            };
            like4.print();
    
            /**
             * lambda表达式
             */
            ILikeMoon like5 = ()-> System.out.print("我是函数式接口-Lambda实现") ;
    
            like5.print();
        }
    }
    
    /**
     * 函数式接口：只包含一个抽象方法的接口
     */
    @FunctionalInterface
    interface ILikeMoon{
        
        /**
         * 我喜欢月亮
         */
        public abstract void print();
    }
    
    /**
     * 外部类
     */
    class Like implements ILikeMoon{
        
    
        @Override
        public void print() {
        
            System.out.println("我是函数式接口-外部类实现");
        }
    }

**二、Lambda使用：**

定义用户对象 UserEntity：

package com.atguigu.entity;
    
    import lombok.Data;
    
    /**
     * Description: 用户类
     *
     * @Author: zhx & moon hongxu_1234@163.com
     * @Date: 2021-04-17 18:07
     * @version: V1.0.0
     */
    @Data
    public class UserEntity {
        
    
        /**
         * 数据ID
         */
        private Integer id;
        /**
         * 用户编码
         */
        private String userCode;
        /**
         * 用户姓名
         */
        private String userName;
        /**
         * 岗位 0：老板 1：经理 2：员工 3：物业
         */
        private Integer position;
        /**
         * 手机号
         */
        private String phone;
        /**
         * 邮箱
         */
        private String email;
    
    
        public UserEntity(String userName,Integer position){
        
            this.userName = userName;
            this.position = position;
        }
    }

定义并初始化 List：

private static final List<UserEntity> list = new ArrayList<>(Arrays.asList(
                new UserEntity("张老板",0,"休斯敦",32),
                new UserEntity("王经理",1,"休斯敦",32),
                new UserEntity("刘经理",1,"休斯敦",32),
                new UserEntity("小赵",2,"普罗米修斯",30),
                new UserEntity("小孙",2,"普罗米修斯",30),
                new UserEntity("小钱",2,"普罗米修斯",31),
                new UserEntity("小汪",2,"普罗米修斯",31),
                new UserEntity("周阿姨",3,"暗黑",30)
        ));

预定义方法

private static String customAttributesGroup (UserEntity userEntity){
        
            return userEntity.getAddress() + "-" + userEntity.getAge();
        }
    
    private static int customAttributesSort (UserEntity first,UserEntity second){
        
            return first.getAge() - second.getAge();
        }

1.利用Lamdba对List按某一属性分组

Map<Integer,List<UserEntity>> mapGroup = list.stream().collect(Collectors.groupingBy(UserEntity::getPosition));
            System.out.println(mapGroup);

2.利用Lamdba对List按自定义方式分组

Map<String,List<UserEntity>> mapGroups = list.stream().collect(Collectors.groupingBy(e->customAttributesGroup(e)));
            System.out.println(mapGroups);

3.将list按对象某一属性排序

List<UserEntity> sortAsc = list.stream().sorted(Comparator.comparing(UserEntity::getAge)).collect(Collectors.toList());
            List<UserEntity> sortDesc = list.stream().sorted(Comparator.comparing(UserEntity::getAge).reversed()).collect(Collectors.toList());
            System.out.println(sortAsc);
            System.out.println(sortDesc);

4.将list按自定义方法排序

List<UserEntity> sortCustomAsc = list.stream().sorted((a,b)->customAttributesSort(a,b)).collect(Collectors.toList());
            List<UserEntity> sortCustomDesc = list.stream().sorted((a,b)->b.getAge()-a.getAge()).collect(Collectors.toList());
            System.out.println(sortCustomAsc);
            System.out.println(sortCustomDesc);

5.将map按主键排序

Map<Integer,List<UserEntity>> mapGroupLinkedAsc = new LinkedHashMap<>();
            Map<Integer,List<UserEntity>> mapGroupLinkedDesc = new LinkedHashMap<>();
            mapGroup.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEachOrdered(x -> mapGroupLinkedAsc.put(x.getKey(),(x.getValue())));
            mapGroup.entrySet().stream().sorted(Map.Entry.<Integer,List<UserEntity>>comparingByKey().reversed()).forEachOrdered(x -> mapGroupLinkedDesc.put(x.getKey(),(x.getValue())));
            System.out.println(mapGroupLinkedAsc);
            System.out.println(mapGroupLinkedDesc);

6.将list按年龄和住址进行过滤

List<UserEntity> listFilter = list.stream().filter(
                    e->e.getAge() < 31 && e.getAddress().equals("暗黑")
            ).collect(Collectors.toList());
            System.out.println(listFilter);

7.遍历list

list.forEach(e-> System.out.println(e.getAddress()));
            list.stream().forEach(e-> System.out.println(e.getAddress()));

8.遍历map

mapGroup.forEach((k,v)-> System.out.println(k + ":" + v));