枚举+接口代替策略模式

痛定思痛。 2024-03-22 12:12 47阅读 0赞

**问题：给定一个集合，按照参数的值不同将集合转换成该类型**

例如传 id 则将 person 集合转换成 id 集合，大概就是这样的需求，看见项目代码实现是使用 if-else 实现，if 里面使用 stream.map 进行转换，由于if 分支太多了，看着不舒服，于是想能不能优化一下，第一想法是使用策略模式，但是为了一个区区的转换使用策略模式得不偿失。

public class Person {
    
        private Integer id;
    
        private String name;
    
        private String address;
    }

在百度一番后找到了两种不错的实现

### 枚举+接口 ###

@FunctionalInterface
    public interface UserInterface {
    
        List<String> transformUser(List<User> users);
    }

public enum UserEnum implements UserInterface{
    
        USER_NAME{
            @Override
            public List<String> transformUser(List<User> users) {
                return users.stream().map(User::getName).collect(Collectors.toList());
            }
        },
        USER_ADDRESS{
            @Override
            public List<String> transformUser(List<User> users) {
                return users.stream().map(User::getAddress).collect(Collectors.toList());
            }
        },
        USER_EMAIL{
            @Override
            public List<String> transformUser(List<User> users) {
                return users.stream().map(User::getEmail).collect(Collectors.toList());
            }
        }
        ;
    }

这种将 if-else 转换成了枚举，看起来跟 if-else 没啥区别，而且还多了两个类

### 枚举+方法引用 ###

public enum MethodEnum {
        NAME(1, User::getName),
        ADDRESS(2, User::getAddress),
        EMAIL(3, User::getEmail)
        ;
    
        private final int value;
    
        private final Function<User, String> function;
    
        MethodEnum(int value, Function<User, String> function) {
            this.value = value;
            this.function = function;
        }
    
        public int getValue() {
            return value;
        }
    
        public Function<User, String> getFunction() {
            return function;
        }
    
        public static Function<User, String> getFunction(int val){
            MethodEnum methodEnum = Arrays.stream(MethodEnum.values()).filter(p -> Objects.equals(p.value, val)).findFirst().orElse(null);
            if (Objects.isNull(methodEnum)){
                throw new IllegalArgumentException("未找到参数");
            }
            return methodEnum.getFunction();
        }
    }

将方法引用当作一个参数，这样更简洁，使用起来比第一种更方便

**测试**

public class Main {
        public static void main(String[] args) {
            ArrayList<User> list = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                User user = new User();
                user.setName("name" + i);
                user.setAddress("address" + i);
                user.setEmail("email" + i);
                list.add(user);
            }
    
            List<String> collect = list.stream().map(MethodEnum.getFunction(1)).collect(Collectors.toList());
            System.out.println(collect);
    
            System.out.println("-----------------------");
            List<String> nameList = UserEnum.USER_NAME.transformUser(list);
            System.out.println(nameList);
    
        }
    }