Gfrktyl

I have an enum with descriptions as String. This is the enum.

public enum tabs

{

    A("Actual data"),

    B("Bad data"),

    C("Can data"),

    D("Direct data");



    private String description;

    tabs(String desc)

    {

        this.description = desc;

    }





    public String getDescription()

    {

        return this.description;

    }

}

Now, if I need the data for A, I'd just do

tabs.A.description

I am in the process of creating a generic method to return the values.

I have managed to utilize the below generic method to accept an enum type as the argument.
It returns an array of the enum constants.
But I actually want it to return an array of the values.. ie {"Actual data", "Bad data", "Can data", "Direct data"}.

public static String getActualTabs(Class<? extends Enum<?>> e) 

{

    return Arrays.stream(e.getEnumConstants()).map(Enum::name).toArray(String::new);

}

What options do I have to achieve this?

You can pass a mapper Function to map enum constants into Strings:

public static <T extends Enum<T>> String getActualTabs(Class<T> e, Function<? super T, String> mapper) 

{

    return Arrays.stream(e.getEnumConstants()).map(mapper).toArray(String::new);

}

Usage:

System.out.println(Arrays.toString(getActualTabs(tabs.class,tabs::getDescription)));

Output:

[Actual data, Bad data, Can data, Direct data]

I'd first pull getDescription out to an interface and make sure all your project's enums implement it:

public interface HasDescription {

    String getDescription();

}

And then, use it in your generic method:

public static String getActualTabs(Class<? extends Enum<?> & HasDescription> e) {

    return Arrays.stream(e.getEnumConstants())

                 .map(HasDescription::getDescription)

                 .toArray(String::new);

}

Both answers are quite beautiful.

But there is another variant which might be more superior because it is even more widely usable:

public static <T> String getActualTabs(T values, Function<? super T, String> mapper) {

    return Arrays.stream(values)

                 .map(mapper)

                 .toArray(String::new);

}



public static <T extends HasDescription> String getActualTabs(T values) {

    return Arrays.stream(values)

                 .map(HasDescription::getDescription)

                 .toArray(String::new);

    // or just: return getActualTabs(values, HasDescription::getDescription);

}

This implementation has the benefit that we don't have to mess around with reflection.

Instead, you would call them this way:

String tabs1 = getActualTabs(Tabs.values())

String tabs2 = getActualTabs(Tabs.values(), Tabs::getDescription)

Note that it might be useful to rename the functions, e. g. getStringifiedValues() or toDescriptions().

Disclaimer: untested, but should work, IMHO.