java - stringdef - ¿Cuál es la mejor manera de implementar `next` y` previous` en un tipo de enumeración?

enum class java android

Question

Supongamos que tengo una enumeración:

enum E {
    A, B, C;
}

Como se muestra en esta respuesta por lucasmo , los valores enum se almacenan en una matriz estática en el orden en que se inicializan, y luego puede recuperar (una clonación de) esta matriz con E.values() .

Ahora supongamos que quiero implementar E#getNext y E#getPrevious modo que todas las siguientes expresiones se evalúen como true :

E.A.getNext() == E.B
E.B.getNext() == E.C
E.C.getNext() == E.A

E.A.getPrevious() == E.C
E.B.getPrevious() == E.A
E.C.getPrevious() == E.B

Mi implementación actual para getNext es la siguiente:

public E getNext() {
    E[] e = E.values();
    int i = 0;
    for (; e[i] != this; i++)
        ;
    i++;
    i %= e.length;
    return e[i];
}

y un método similar para getPrevious .

Sin embargo, este código parece engorroso en el mejor de los casos (p. Ej., "Vacío" for ciclo, abuso discutible de una variable contraria, y potencialmente erróneo en el peor (reflexión del pensamiento, posiblemente).

¿Cuál sería la mejor forma de implementar los métodos getNext y getPrevious para los tipos enum en Java 7?

NOTA: No pretendo que esta pregunta sea subjetiva. Mi solicitud para la "mejor" implementación es una abreviatura para solicitar la implementación que es la más rápida, más limpia y más sostenible.

Answer 1

Alternativamente, uno puede ir de alguna manera a lo largo de las líneas de la siguiente idea:

public enum SomeEnum {
  A, B, C;

  public Optional<SomeEnum> next() {
    switch (this) {
      case A: return Optional.of(B);
      case B: return Optional.of(C);
      // any other case can NOT be mapped!
      default: return Optional.empty();
  }
}

Notas:

1. En contraste con la otra respuesta, de esta manera se hace un mapeo implícito ; en lugar de confiar en ordinal() . Por supuesto, eso significa más código; pero también obliga al autor a considerar lo que significa agregar nuevas constantes o eliminar las existentes. Cuando se basa en ordinal, su suposición implícita es que el orden se basa en el orden utilizado para la declaración constante enum. Entonces, cuando alguien vuelve 6 meses después y tiene que agregar una nueva constante, tiene que entender que la nueva constante Y necesita X, Y, Z ... ¡en lugar de simplemente agregar X, Z, Y !
2. Puede haber situaciones en las que no tenga ningún sentido que la "última" constante enum tenga el "primero" como sucesor. Piense en tamaños de camisetas para ejemplos. XXL.next () no es XS. Para tales situaciones, usar Opcional es la respuesta más apropiada.

Answer 2

Prueba esto:

public static enum A { 
    X, Y, Z;
    private static A[] vals = values();
    public A next()
    {
        return vals[(this.ordinal()+1) % vals.length];
    }

La implementación de previous() se deja como un ejercicio, pero recuerde que en Java, el módulo a % b puede devolver un número negativo .

EDITAR: como se sugiere, haga una copia estática privada de la matriz de values() para evitar la copia en matriz cada vez que se invoque next() o previous() .