java编写以枚举和字符串为参数的泛型方法

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);