Преобразовать из порядкового номера перечисления в тип перечисления

У меня есть тип enum, ReportTypeEnumкоторый передается между методами во всех моих классах, но затем мне нужно передать это по URL-адресу, чтобы я использовал порядковый метод для получения значения int. После того, как я получу его на другой моей странице JSP, мне нужно преобразовать его обратно в формат, ReportTypeEnumчтобы я мог продолжить его передачу.

Как я могу преобразовать порядковый номер в ReportTypeEnum?

Использование Java 6 SE.

Чтобы преобразовать порядковый номер в его представление enum, вы можете сделать это:

ReportTypeEnum value = ReportTypeEnum.values()[ordinal];

Пожалуйста, обратите внимание на границы массива.

Обратите внимание, что каждый вызов values()возвращает новый клонированный массив, который может отрицательно повлиять на производительность. Вы можете кэшировать массив, если он будет часто вызываться.

Пример кода о том, как кешироватьvalues() .

_{Этот ответ был отредактирован, чтобы включить обратную связь, данную внутри комментариев}

Это почти наверняка плохая идея . Конечно, если порядковый номер де-факто сохраняется (например, потому что кто-то добавил закладку в URL) - это означает, что вы всегда должны сохранять enumпорядок в будущем, что может быть неочевидно для сопровождающих кода в дальнейшем.

Почему бы не кодировать enumиспользование myEnumValue.name()(и декодировать через ReportTypeEnum.valueOf(s)) вместо этого?

Если я собираюсь использовать values()много:

enum Suit {
   Hearts, Diamonds, Spades, Clubs;
   public static final Suit values[] = values();
}

Тем временем где.java:

Suit suit = Suit.values[ordinal];

Следите за границами вашего массива.

Я согласен с большинством людей, что использование порядкового номера, вероятно, плохая идея. Обычно я решаю эту проблему, предоставляя enum приватный конструктор, который может принимать, например, значение DB, а затем создавать статическую fromDbValueфункцию, аналогичную той, что была в ответе Яна.

public enum ReportTypeEnum {
    R1(1),
    R2(2),
    R3(3),
    R4(4),
    R5(5),
    R6(6),
    R7(7),
    R8(8);

    private static Logger log = LoggerFactory.getLogger(ReportEnumType.class);  
    private static Map<Integer, ReportTypeEnum> lookup;
    private Integer dbValue;

    private ReportTypeEnum(Integer dbValue) {
        this.dbValue = dbValue;
    }


    static {
        try {
            ReportTypeEnum[] vals = ReportTypeEnum.values();
            lookup = new HashMap<Integer, ReportTypeEnum>(vals.length);

            for (ReportTypeEnum  rpt: vals)
                lookup.put(rpt.getDbValue(), rpt);
         }
         catch (Exception e) {
             // Careful, if any exception is thrown out of a static block, the class
             // won't be initialized
             log.error("Unexpected exception initializing " + ReportTypeEnum.class, e);
         }
    }

    public static ReportTypeEnum fromDbValue(Integer dbValue) {
        return lookup.get(dbValue);
    }

    public Integer getDbValue() {
        return this.dbValue;
    }

}

Теперь вы можете изменить порядок без изменения поиска и наоборот.

Вы можете использовать статическую таблицу поиска:

public enum Suit {
  spades, hearts, diamonds, clubs;

  private static final Map<Integer, Suit> lookup = new HashMap<Integer, Suit>();

  static{
    int ordinal = 0;
    for (Suit suit : EnumSet.allOf(Suit.class)) {
      lookup.put(ordinal, suit);
      ordinal+= 1;
    }
  }

  public Suit fromOrdinal(int ordinal) {
    return lookup.get(ordinal);
  }
}

Это то, что я использую. Я не претендую на то, что он гораздо менее «эффективен», чем простые решения выше. Что он делает, так это предоставляет гораздо более четкое сообщение об исключении, чем «ArrayIndexOutOfBounds», когда в решении выше используется недопустимый порядковый номер.

Он использует тот факт, что EnumSet javadoc указывает, что итератор возвращает элементы в их естественном порядке. Есть утверждение, что это не правильно.

Тест JUnit4 демонстрирует, как он используется.

 /**
 * convert ordinal to Enum
 * @param clzz may not be null
 * @param ordinal
 * @return e with e.ordinal( ) == ordinal
 * @throws IllegalArgumentException if ordinal out of range
 */
public static <E extends Enum<E> > E lookupEnum(Class<E> clzz, int ordinal) {
    EnumSet<E> set = EnumSet.allOf(clzz);
    if (ordinal < set.size()) {
        Iterator<E> iter = set.iterator();
        for (int i = 0; i < ordinal; i++) {
            iter.next();
        }
        E rval = iter.next();
        assert(rval.ordinal() == ordinal);
        return rval;
    }
    throw new IllegalArgumentException("Invalid value " + ordinal + " for " + clzz.getName( ) + ", must be < " + set.size());
}

@Test
public void lookupTest( ) {
    java.util.concurrent.TimeUnit tu = lookupEnum(TimeUnit.class, 3);
    System.out.println(tu);
}

Вот что я делаю на Android с Proguard:

public enum SomeStatus {
    UNINITIALIZED, STATUS_1, RESERVED_1, STATUS_2, RESERVED_2, STATUS_3;//do not change order

    private static SomeStatus[] values = null;
    public static SomeStatus fromInteger(int i) {
        if(SomeStatus.values == null) {
            SomeStatus.values = SomeStatus.values();
        }
        if (i < 0) return SomeStatus.values[0];
        if (i >= SomeStatus.values.length) return SomeStatus.values[0];
        return SomeStatus.values[i];
    }
}

это коротко, и мне не нужно беспокоиться о наличии исключения в Proguard

Вы можете определить простой метод как:

public enum Alphabet{
    A,B,C,D;

    public static Alphabet get(int index){
        return Alphabet.values()[index];
    }
}

И используйте это как:

System.out.println(Alphabet.get(2));

public enum Suit implements java.io.Serializable, Comparable<Suit>{
  spades, hearts, diamonds, clubs;
  private static final Suit [] lookup  = Suit.values();
  public Suit fromOrdinal(int ordinal) {
    if(ordinal< 1 || ordinal> 3) return null;
    return lookup[value-1];
  }
}

тестовый класс

public class MainTest {
    public static void main(String[] args) {
        Suit d3 = Suit.diamonds;
        Suit d3Test = Suit.fromOrdinal(2);
        if(d3.equals(d3Test)){
            System.out.println("Susses");
        }else System.out.println("Fails");
    }
}

Я ценю, что вы поделитесь с нами, если у вас есть более эффективный код, Мой список огромен и постоянно вызывается тысячи раз.

Таким образом, один из способов - сделать то, ExampleEnum valueOfOrdinal = ExampleEnum.values()[ordinal];что работает, и это легко, однако, как уже упоминалось, ExampleEnum.values()возвращает новый клонированный массив для каждого вызова. Это может быть излишне дорого. Мы можем решить это, кэшируя массив следующим образом ExampleEnum[] values = values(). Также «опасно» разрешать изменение нашего кэшированного массива. Кто-то может написать ExampleEnum.values[0] = ExampleEnum.type2;Так что я бы сделал это приватным с помощью метода доступа, который не выполняет дополнительное копирование.

private enum ExampleEnum{
    type0, type1, type2, type3;
    private static final ExampleEnum[] values = values();
    public static ExampleEnum value(int ord) {
        return values[ord];
    }
}

Вы бы использовали, ExampleEnum.value(ordinal)чтобы получить значение enum, связанное сordinal

Каждое перечисление имеет имя (), которое дает строку с именем члена перечисления.

Учитывая enum Suit{Heart, Spade, Club, Diamond}, Suit.Heart.name()даст Heart.

Каждое перечисление имеет valueOf() метод, который принимает тип перечисления и строку для выполнения обратной операции:

Enum.valueOf(Suit.class, "Heart")возвращается Suit.Heart.

Почему кто-то будет использовать ординалы, мне не под силу. Это может быть наносекундами быстрее, но это небезопасно, если члены перечисления меняются, поскольку другой разработчик может не знать, что какой-то код полагается на порядковые значения (особенно на странице JSP, процитированной в вопросе, издержки сети и базы данных полностью доминируют время, не используя целое число над строкой).