Полиморфное преобразование значений перечисления Java в список строк

Вы можете вставить этот метод в некоторый служебный класс:

public static <T extends Enum<T>> List<String> getDisplayValues(Class<T> enumClass) {
    try {
        T[] items = enumClass.getEnumConstants();
        Method accessor = enumClass.getMethod("getDisplayValue");

        ArrayList<String> names = new ArrayList<String>(items.length);
        for (T item : items)
            names.add(accessor.invoke(item).toString()));

        return names;
    } catch (NoSuchMethodException ex) {
        // Didn't actually implement getDisplayValue().
    } catch (InvocationTargetException ex) {
        // getDisplayValue() threw an exception.
    }
}

Источник: Examining Enums

Здесь вы можете сделать две вещи. Первый (более простой и, следовательно, лучший) способ будет заключаться в том, чтобы ваш метод getStrings () взял список некоторого интерфейса и заставил ваши перечисления реализовывать этот интерфейс:

public interface DisplayableSelection {
  public String getDisplayValue();
}

private static List<String> getStrings (Collection<DisplayableSelection> things) {
  List<String> retval = new ArrayList<String>();
  for (DisplayableSelection thing : things) {
    retval.add(thing.getDisplayValue());
  }
}

private static List<String> getColours () {
  return getStrings(Colour.values());
}

Если вы действительно заботитесь о том, что типом является Enum, вы также можете использовать тот факт, что все перечисляемые типы автоматически создают подклассы встроенного типа Enum. Итак, для вашего примера (отказ от ответственности: я думаю , что это компилируется, но на самом деле не пробовал):

public interface DisplayableEnum {
  public String getDisplayValue();
}

private static <T extends Enum<T> & DisplayableEnum > List<String> getDisplayValues(Class<T> pClass) {
  List<String> retval = new ArrayList<String>();
  for (DisplayableSelection thing : pClass.getEnumConstants()) {
    retval.add(thing.getDisplayValue());
  }
}

private static List<String> getColours () {
  return getStrings(Colour.class);
}

Эта вторая форма может быть полезна, если вы хотите сделать что-то, что конкретно требует перечисления (например, по какой-то причине используйте EnumMap или EnumSet); в противном случае я бы выбрал первый (поскольку с этим методом вы также можете использовать неперечислимые типы или просто подмножество перечисления).

Этот подход позволяет избежать отражения:

  public static interface Displayer<T> {
    String displayName(T t);
  }

  public static <T> List<String> getDisplayNames(Iterable<? extends T> stuff,
      Displayer<T> displayer) {
    List<String> list = new ArrayList<String>();
    for (T t : stuff) {
      list.add(displayer.displayName(t));
    }
    return list;
  }

... но требует отдельного типа для всего, что вы хотите отобразить:

  enum Foo {
    BAR("BAR"), BAZ("BAZ");
    private final String displayName;

    private Foo(String displayName) {
      this.displayName = displayName;
    }

    public String getDisplayName() {
      return displayName;
    }
  }

  public static void main(String[] args) {
    Displayer<Foo> fooDisplayer = new Displayer<Foo>() {
      public String displayName(Foo foo) {
        return foo.getDisplayName();
      }
    };

    System.out.println(getDisplayNames(Arrays.asList(Foo.BAR, Foo.BAZ),
        fooDisplayer));
  }

В этом случае используется анонимный тип, но он может быть одиночкой без гражданства или кем-то подобным.

Я бы использовал java.util.ResourceBundle с файлом пакета, который соответствует значениям toString (и, возможно, имени класса) вашего перечисляет, поэтому ваш код будет выглядеть примерно так:

bundle.getString(enum.getClass().getName() + enum.toString());

Вот как я бы посоветовал это сделать:

Сначала вспомогательный метод и статический внутренний класс где-нибудь в служебном классе:

    @SuppressWarnings("unchecked")
    public static <T> T generateProxy(Object realObject, Class<?>... interfaces) {
        return (T) Proxy.newProxyInstance(realObject.getClass().getClassLoader(), interfaces, new SimpleInvocationHandler(realObject));
    }


    private static class SimpleInvocationHandler implements InvocationHandler {
        private Object invokee;

        public SimpleInvocationHandler(Object invokee) {
            this.invokee = invokee;
        }

        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            method = invokee.getClass().getMethod(method.getName(), method.getParameterTypes());
            if (!method.isAccessible()) {
                method.setAccessible(true);
            }
            try {
                return method.invoke(invokee, args);
            } catch (InvocationTargetException e) {
                throw e.getTargetException();
            }
        }
    }

А затем соедините это вместе со своим перечислением:

   interface DisplayableEnum {
       String getDisplayValue();
   }

private static List<String> getFromEnum(Class<? extends Enum<?>> displayableEnum) {
    List<String> ret = new ArrayList<String>();
    for (Enum e : displayableEnum.getEnumConstants()) {
        DisplayableEnum de = generateProxy(e, DisplayableEnum.class);
        ret.add(de.getDisplayValue());
    }
    return ret;
}

Если производительность является проблемой, связанной с созданием такого большого количества прокси-объектов, я бы пошел по пути создания изменяемого класса, реализующего DisplayableEnum, который может изменяться с каждой константой перечисления (своего рода легковесный шаблон), и иметь там обработчик вызова, который более гибок в отношении своего реального объекта и вызывает правильный объект при каждом проходе цикла.

Обратите внимание, что я знаю, что перечисления в вопрос будет у всех getDisplayValue, но к сожалению, они не разделяют общий тип, который его определяет (и я не могу представить один), поэтому я предполагаю, что нужно будет получить доступ задумчиво ...?

Вы правильно угадываете. Альтернативой было бы, чтобы все перечисления реализуют toString () , возвращая отображаемое значение - но если вы не можете заставить их реализовать интерфейс, то я полагаю, что это тоже невозможно.

(извините, это C #. Я не видел, чтобы вопрос касался Java.)

public string[] GetValues<T>()
{
    return Enum.GetNames(typeof(T));
}

Для Java, конечно, все типы перечислений по-прежнему наследуются от java.util.Enum, поэтому вы можете написать:

public string[] getValues<T extends Enum<T>>()
{
    // use reflection on T.class
}

Поскольку java.util.Enum на самом деле не реализует values ​​(), я думаю, что отражение - единственный выход.