Learning to use ENUM in Java

Question

Good afternoon.

I’m learning to use the guys enum in Java and facing some problems.

First of all, I created my own enum as follows:

public enum enumUpdateAction {
    NEW(0), CHANGE(1), DELETE(2), DELETE_THRU(3), DELETE_FROM(4);

    public int codigo;

    enumUpdateAction(int codigo) {
        this.codigo = codigo;
    }

    public int getCodigo() {
        return this.codigo;
    }
}

Now, I need to use such an Enum inside a Switch, in another class:

public static LinkedList<LinkedList<Eventos>> Working(enum_type tipo, enum_updateAction updateAction) {

    switch (Eventos.get(0).getUpdateaction()) {

        case enum_updateAction.NEW://enum_updateAction.NEW: // 0 = new
                ArrayEventos.add(InserirOrdenado(ArrayEventos, Ordem), Ordem);
                break;

    }


}

The Eventos.get(0).getUpdateaction() returns a int. I could use in cases numbers from 0 to 2, but how do I know that each number represents BID, OFFER or TRADE, I’m trying to use these words directly on switch, with the aid of enum. Meanwhile, I get that "enum_updateAction.NEW cannot be converted to int". Can anyone tell me how I get the number value of NEW of enum, and not the word NEW in itself?

Answer 1

All enum has a method called ordinal() which gives the position in which it was declared within the class, the first element being that of ordinal() == 0. Why, that’s exactly what your field codigo makes. So, you don’t need to use this field to reinvent the wheel, just use the ordinal().

public enum EnumUpdateAction {
    NEW, CHANGE, DELETE, DELETE_THRU, DELETE_FROM;
}

Moreover, all enum has a method values() which returns an array of the same type as enum containing the elements of that enum in the order in which they are defined. You can use this to translate the values of ordinal() for the elements.

In the switch, you can use the elements of enums directly, referencing them by their respective names. Do not need any code int for that reason:

public static List<? extends List<Eventos>> working(EnumType tipo, EnumUpdateAction updateAction) {

    switch (EnumUpdateAction.values()[eventos.get(0).getUpdateAction()]) {
        case NEW:
            ArrayEventos.add(inserirOrdenado(arrayEventos, ordem), ordem);
            break;
        case CHANGE:
            // ...
            break;
        case DELETE:
            // ...
            break;
    }
}

I also notice that if eventos.get(0) return EnumUpdateAction instead of int, your switch would be simpler:

switch (eventos.get(0)) {

Also, please obey the language conventions.

And I notice that maybe in your code, what you really wanted was a switch (updateAction) { ... }.

See in ideone an example with enum in switch:

class EnumComSwitch {
    private static enum MeuEnum {
        NEW, CHANGE, DELETE, BLABLA;
    }

    public static void main(String[] args) {
        MeuEnum elemento = MeuEnum.CHANGE;
        switch (elemento) {
            case NEW:
                System.out.println("Este é o NEW");
                break;
            case CHANGE:
                System.out.println("Este é o CHANGE");
                break;
            case DELETE:
                System.out.println("Este é o DELETE");
                break;
            case BLABLA:
                System.out.println("Este é o BLABLA");
                break;
        }
    }
}

Answer 2

First I’ll use another name for enum, considering the convection of code, which classes should start with capital letters and _ should be avoided.

There are several ways to make the comparison you want, one of them is to transform the int that represents noo enum (consisderando que you can put any code in any order) desired.

public enum Type {
  BID(0), OFFER(1), TRADE(2);

  public final int codigo;

  private Type(int codigo) {
    this.codigo = codigo;
  }

  public int getCodigo() {
    return this.codigo;
  }

  public static Type getType(int codigo) {
    for(Type type : Type.values()) {
      if (type.getCodigo() == codigo) {
        return type;
      }
    }

    return null;
  }
}

So your comparison would be as follows:

public static LinkedList<LinkedList<Eventos>> working() {
  Type type = Type.getType(Eventos.get(0).getUpdateaction());

  switch(type) {
      case Type.NEW:
        arrayEventos.add(InserirOrdenado(arrayEventos, ordem), ordem);
        break;
  }
}

Note that I used the method Type#get to transform the int of Eventos.get(0).getUpdateaction() to obtain the enum concerning him.

---

The second way would be, using the implementation of enum previous, check as follows:

public static LinkedList<LinkedList<Eventos>> working() {
  switch(Eventos.get(0).getUpdateaction()) {
      case Type.NEW.getCodigo():
        ArrayEventos.add(InserirOrdenado(arrayEventos, ordem), ordem);
        break;
  }
}

If you guarantee that the order will actually refer to int that will use there is a solution in this answer.

---

Reference:

Answer to a similar question in Stackoverflow: How to Retrieve Enum name using the id?