java - Write generic method which takes enum and string as arguments

Question

Please suggest. Suppose I have two enums as shown below. I'm performing tasks if enum values match my string.

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

And I want below work to be generic for both cases:

//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

The only thing you need from both enums in this code:

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

        }
    } );

is the getValue method.

So you can create an interface that has this method:

interface HasValue {
    String getValue();
}

Make both enums implement the interface:

public enum Action implements HasValue {
    ...
}

public enum Days implements HasValue {
    ...
}

Then you can write a generic method:

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

        }
    });
}

You can call it like this:

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

The method doesn't actually have to be generic. You could just do:

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

If you can't change Days or Action, you can use a functional interface instead:

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