编写以枚举和字符串为参数的通用方法

Question

请提出建议。假设我有两个枚举，如下所示。如果枚举值与我的字符串匹配，我正在执行任务。

public enum Action {
        DO("DO"),
        REDO("REDO"),
        ROLLBACK("DONT");

        private String value;

        private Action(String value) {
            this.value = value;
        }

        public String getValue() {
            return this.value;
        }
    }

public enum Days {
        WEEK("WORK"),
        LEAVE("DONT WORK");

        private String value;

        private Days(String value) {
            this.value = value;
        }

        public String getValue() {
            return this.value;
        }
    }

我希望下面的工作对这两种情况都是通用的：

//any String 
String sp ="do";

        Arrays.stream(Action.values()).forEach(e ->{
            if(e.getValue().equalsIgnoreCase(sp)){
                //System.out.println(sp); Some work to do here

            }
        } );

Answer 1

这段代码中你唯一需要的就是两个枚举：

    Arrays.stream(Action.values()).forEach(e ->{
        if(e.getValue().equalsIgnoreCase(sp)){
            //System.out.println(sp); Some work to do here

        }
    } );

是getValue 方法。

所以你可以创建一个有这个方法的接口：

interface HasValue {
    String getValue();
}

让两个枚举都实现接口：

public enum Action implements HasValue {
    ...
}

public enum Days implements HasValue {
    ...
}

然后你可以写一个泛型方法：

public <T extends HasValue> void foo(T[] values, String sp) {
    Arrays.stream(values).forEach(e ->{
        if(e.getValue().equalsIgnoreCase(sp)){
            //System.out.println(sp);

        }
    });
}

你可以这样称呼它：

foo(Action.values(), sp);
foo(Days.values(), sp);

该方法实际上不必是通用的。你可以这样做：

public void foo(HasValue[] values, String sp) {
    ...
}

如果无法更改Days 或Action，则可以改用函数式接口：

public <T> void foo(T[] values, Function<T, String> getValue, String sp) {
    Arrays.stream(values).forEach(e ->{
        if(getValue.apply(e).equalsIgnoreCase(sp)){
            //System.out.println(sp);

        }
    });
}

// usage:

foo(Action.values(), Action::getValue, sp);
foo(Days.values(), Days::getValue, sp);