Was ist der beste Weg, `next` und` previous` für einen Enum-Typ zu implementieren?

Question

Angenommen, ich habe eine Enumeration:

enum E { 
    A, B, C; 
} 

Wie in this answer von lucasmo werden in einem statischen Array in der Reihenfolge gespeicherten Werte Enum gezeigt, dass sie initialisiert werden, und Sie können später abgerufen werden (ein Klon) dieses Array mit E.values().

Jetzt nehme ich an E#getNext und E#getPrevious so implementieren möchten, dass alle folgenden Ausdrücke auswerten zu 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 

Meine aktuelle Implementierung für getNext ist folgende:

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

und eine ähnliche Methode für getPrevious.

Allerdings scheint dieser Code umständlich besten (zB „leer“ for Schleife, arguable Missbrauch einer Zählvariable und möglicherweise fehlerhaft im schlimmsten Fall (Denken Reflexion, möglicherweise).

Was wäre der beste Weg, zu implementieren getNext und getPrevious Methoden für enum-Typen in Java 7

---

HINWEIS: Meine Anfrage ich nicht die Absicht, diese Frage subjektiv zu sein für den „best“ Implemen. Es ist eine Kurzform, nach der Implementierung zu fragen, die am schnellsten, saubersten und am besten wartbar ist.

Answer 1

Versuchen Sie folgendes:

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

Implementierung von previous() wird als Übung, aber daran erinnern, dass in Java, the modulo a % b can return a negative number.

EDIT: Wie vorgeschlagen, eine private statische Kopie der values() Array zu vermeiden Array-Kopieren jedes Mal next() oder previous() wird aufgerufen.

Answer 2

Alternativ kann man irgendwie entlang der Linien der folgenden Idee gehen:

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(); 
    } 
} 

Hinweise:

1. Im Gegensatz zu den anderen Antwort, auf diese Weise hat einige implizite Mapping; anstatt sich auf ordinal() zu verlassen. Natürlich bedeutet das mehr Code; aber es zwingt auch den Autor zu betrachten was es bedeutet, neue Konstanten hinzuzufügen oder vorhandene zu entfernen. Wenn Sie sich auf ordinal verlassen, ist Ihre implizite Annahme, dass die Bestellung auf der Reihenfolge basiert, die für die Enum-Konstante-Deklaration verwendet wird. Wenn also jemand 6 Monate später wiederkommt und eine neue Konstante hinzufügen muss, muss er verstehen, dass die neue Konstante Y X, Y, Z ... braucht, anstatt nur X, Z, Y anzufügen!
2. Es kann Situationen geben, in denen es keinen Sinn macht, dass die "letzte" Enum-Konstante den "ersten" als Nachfolger hat. Denken Sie an T-Shirt Größen für Beispiele. XXL.next() ist sicher nicht XS. In solchen Fällen ist die Verwendung von Optional die geeignetere Antwort.