使用 java 泛型迭代枚举值

小开

最佳答案

This is a hard problem indeed. One of the things you need to do is tell java that you are using an enum. This is by stating that you extend the Enum class for your generics. However this class doesn't have the values() function. So you have to take the class for which you can get the values.

The following example should help you fix your problem:

public <T extends Enum<T>> void enumValues(Class<T> enumType) {
for (T c : enumType.getEnumConstants()) {
System.out.println(c.name());
}
}

小开

The root problem is that you need to convert an array to a list, right? You can do this, by using a specific type (TimePeriod instead of T), and the following code.

So use something like this:

List<TimePeriod> list = new ArrayList<TimePeriod>();
list.addAll(Arrays.asList(sizes));

Now you can pass list into any method that wants a list.

小开

If you are sure that selectedOption of the constructor Filter(T selectedOption) is not null. You can use reflection. Like this.

public class Filter<T> {
private List<T> availableOptions = new ArrayList<T>();
private T selectedOption;


public Filter(T selectedOption) {
this.selectedOption = selectedOption;
for (T option : this.selectedOption.getClass().getEnumConstants()) {  // INVALID CODE
availableOptions.add(option);
}
}
}

Hope this helps.

小开

Using an unsafe cast:

class Filter<T extends Enum<T>> {
private List<T> availableOptions = new ArrayList<T>();
private T selectedOption;


public Filter(T selectedOption) {
Class<T> clazz = (Class<T>) selectedOption.getClass();
for (T option : clazz.getEnumConstants()) {
availableOptions.add(option);
}
}
}

小开

Another option is to use EnumSet:

class PrintEnumConsants {


static <E extends Enum <E>> void foo(Class<E> elemType) {
for (E e : java.util.EnumSet.allOf(elemType)) {
System.out.println(e);
}
}


enum Color{RED,YELLOW,BLUE};
public static void main(String[] args) {
foo(Color.class);
}


}

小开

If you declare Filter as

public class Filter<T extends Iterable>

then

import java.util.Iterator;


public enum TimePeriod implements Iterable {
ALL("All"),
FUTURE("Future"),
NEXT7DAYS("Next 7 Days"),
NEXT14DAYS("Next 14 Days"),
NEXT30DAYS("Next 30 Days"),
PAST("Past"),
LAST7DAYS("Last 7 Days"),
LAST14DAYS("Last 14 Days"),
LAST30DAYS("Last 30 Days");


private final String name;


private TimePeriod(String name) {
this.name = name;
}


@Override
public String toString() {
return name;
}


public Iterator<TimePeriod> iterator() {
return new Iterator<TimePeriod>() {


private int index;


@Override
public boolean hasNext() {
return index < LAST30DAYS.ordinal();
}


@Override
public TimePeriod next() {
switch(index++) {
case    0   : return        ALL;
case    1   : return        FUTURE;
case    2   : return        NEXT7DAYS;
case    3   : return        NEXT14DAYS;
case    4   : return        NEXT30DAYS;
case    5   : return        PAST;
case    6   : return        LAST7DAYS;
case    7   : return        LAST14DAYS;
case    8   : return        LAST30DAYS;
default: throw new IllegalStateException();
}
}


@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
}

And usage is quite easy:

public class Filter<T> {
private List<T> availableOptions = new ArrayList<T>();
private T selectedOption;


public Filter(T selectedOption) {
this.selectedOption = selectedOption;
Iterator<TimePeriod> it = selectedOption.iterator();
while(it.hasNext()) {
availableOptions.add(it.next());
}
}
}

小开

Here below an example of a wrapper class around an Enum. Is a little bit weird bu is what i need :

public class W2UIEnum<T extends Enum<T> & Resumable> {


public String id;
public String caption;


public W2UIEnum(ApplicationContext appContext, T t) {
this.id = t.getResume();
this.caption = I18N.singleInstance.getI18nString(t.name(), "enum_"
+ t.getClass().getSimpleName().substring(0, 1).toLowerCase()
+ t.getClass().getSimpleName().substring(1,
t.getClass().getSimpleName().length()), appContext
.getLocale());
}


public static <T extends Enum<T> & Resumable> List<W2UIEnum<T>> values(
ApplicationContext appContext, Class<T> enumType) {
List<W2UIEnum<T>> statusList = new ArrayList<W2UIEnum<T>>();
for (T status : enumType.getEnumConstants()) {
statusList.add(new W2UIEnum(appContext, status));
}
return statusList;
}

}

小开

For completeness, JDK8 gives us a relatively clean and more concise way of achieving this without the need to use the synthethic values() in Enum class:

Given a simple enum:

private enum TestEnum {
A,
B,
C
}

And a test client:

@Test
public void testAllValues() {
System.out.println(collectAllEnumValues(TestEnum.class));
}

This will print {A, B, C}:

public static <T extends Enum<T>> String collectAllEnumValues(Class<T> clazz) {
return EnumSet.allOf(clazz).stream()
.map(Enum::name)
.collect(Collectors.joining(", " , "\"{", "}\""));
}

Code can be trivially adapted to retrieve different elements or to collect in a different way.

小开

To get the value of the generic enumeration:

  protected Set<String> enum2set(Class<? extends Enum<?>> e) {
Enum<?>[] enums = e.getEnumConstants();
String[] names = new String[enums.length];
for (int i = 0; i < enums.length; i++) {
names[i] = enums[i].toString();
}
return new HashSet<String>(Arrays.asList(names));
}

Note in the above method the call to the toString() method.

And then define the enumeration with such a toString() method.

public enum MyNameEnum {


MR("John"), MRS("Anna");


private String name;


private MyNameEnum(String name) {
this.name = name;
}


public String toString() {
return this.name;
}


}

小开

I did it like this

    protected List<String> enumToList(Class<? extends Enum<?>> e) {
Enum<?>[] enums = e.getEnumConstants();
return Arrays.asList(enums).stream()
.map(name -> name.toString())
.collect(Collectors.toList());
}