Mit Enum ist ordinalen Wert in switch-case-Anweisung

Für mein Projekt bin ich mit enums und ich brauche zur Umsetzung der switch-case-Anweisung, wo die Ordnungszahlen der Werte der bestimmten Enum geprüft werden, wie dieser Weg:

        switch ( variable )
        {
        case MyEnum.A.ordinal():
            return true;
        case MyEnum.B.ordinal():
            return true;
        default:
            return false;
        }

Hinweis: Rückgabe-Werte sind nur ein Beispiel.

Leider, Eclipse (ich bin mit 1.6 JDK) gibt meine Zusammenstellung-Fehler " - Fall
Ausdrücke müssen Konstante Ausdrücke". Was sollte ich tun? Gibt es eine andere Methode als statische lookup-Tabelle, hier beschrieben: Konvertieren von enum Ordnungszahl zu enum-Typ ?

Ich glaube, ich verstehe nicht, warum man mit der Ordnungszahl. Warum können Sie nicht einfach schalten Sie das enum selbst?
Einfach nur neugierig, aber warum bist du mit enums, wenn Sie dann Variablen verwenden die ordinale Werte? Der Punkt des enums ist Ihre Art Sicherheit, aber die variable ist nicht Typ-sicher.. Naja, es könnte so etwas einfaches wie die Herstellung der Ordinalwert eine öffentliche Konstante Attribut statt der Zugriff über eine getter-Methode.
Weil ich muss ordinalen Wert - enum-Werte sind nicht sinnvoll, für diesen bestimmten Zweck, denn Sie stehen in keinem Zusammenhang zu den Ergebnissen der switch-Anweisung.
Ich muss zugeben, das macht für mich keinen Sinn - Wie kann man den enum-Wert nicht auf das Ergebnis der switch-Wert? Die Ordnungszahl wird nur ein index auf die enum-Werte (ein index, der sich ändern kann, wenn Sie fügen Sie ein neues enum-Wert) - Die Ordnungszahlen, indem es die Natur ist nichts weiter als eine vorübergehende Eigenschaft des enum.
durch die Art und Weise, was Sie Fragen ist EnumSet
Die enum-Mitglied kann werden gespeichert in einer Datenbank (mit Ihrer Ordnungszahl Wert), in dem Fall ist das nötig.

InformationsquelleAutor DoktorNo | 2011-07-23

18

Dies ist, wie getan wird, vorausgesetzt, Sie haben eine serialisierte Ordnungszahl irgendwie, irgendwo. Gewohnter Weise beibehalten eines enum ist durch seinen Namen, nicht ordinal, obwohl. Auch sollten Sie nicht verwenden die Ordnungszahl in normalen Umständen, es sei denn, zu versuchen, so etwas wie EnumMap/Set. Natürlich, die enum kann nur ein port von C gleichermaßen Zeug und den Umgang mit den unvermeidlichen int, muss eine Transformation auf das Enum-Objekt.

Verwenden Sie einfach Enum.values() auf, um ein array bestellt ordinal(), da das array geklont jeder Zeit, halten Sie ein ref-Richtung ist ok.
```
enum E{
 A, B, C...   
}

final static E[] vals = E.values();//copy the values(), calling values() clones the array
boolean f(int variable){
  switch(vals[variable]){
  case A:
...
  case B:
...
//break;
  default:
...
   }
}
```
Nur bemerkt, dass Sie brauchen nur true und false, dass ist ein Art von Verhalten. Sie können die Verwendung von java.util.EnumSet oder eine einfache long, wenn mutig (und nicht mit mehr als 64 enum-Konstanten). zum Beispiel:
```
private static <E extends Enum> long ord(E e){
  return 1L<<e.ordinal();
}

static final long positiveSet = ord(E.A)+ord(E.B);
boolean f(int ordinal){
  return 0!=(positiveSet&(1L<<ordinal));
}
```
InformationsquelleAutor
4

Erste von allen, sollten Sie nicht verlassen sich auf die Ordnungszahl, die viel. Wenn möglich, stellen Sie Ihrer variable ein String (und zu transformieren, um enum mit Enum.valueOf(string) oder am besten machen Sie es enum.

Wenn Sie wirklich nicht können, dann verwenden Sie enum.values()[ordinal].Dann verwenden Sie die enum in-Schalter.
- die Iteration ist schlecht in diesem Fall, nur enum.values()[variable], was Sie brauchen. Da values() Klone der array, Sie wären besser dran, wenn es in eine statische variable.
- du bist willkommen, mein Punkt ist, dass, Durchlaufen völlig Niederlagen der Zweck of Fall/switch-Anweisung, die hat Leistung im Verstand.
- vereinbart. Ich habe es als last-option (obwohl es sieht aus wie der OP will)
InformationsquelleAutor Bozho

Die Antwort Zielvorgaben @Riaan Kommentar auf Konstante vs-Methode enums-und performance-Gründen nicht direkt Antworten der OP Frage, so kann es als Rauschen, nehme ich an.
Ich glaube jedoch, es ist wichtig zu verstehen, wie das Innenleben.

Nahm ich den benchmark aus seinem Beispiel und verbessert es zum löschen der garbage collection und der string-Erstellung, übernimmt 90% der Ausführungszeit. Hinzugefügt warm-up-phase, um sicherzustellen hotspot tatsächlich stellt die Methoden.

Gibt es einige mehr, die benchmark ist effektiv callsite-test. Die Optimierung für callsites ganz anders sind, für 1, für 2 für einige mehr und für noch mehr-mehr. Eine callsite ist eine Anrufung des abstrakten (oder auch nur überschriebene) Methode.

Unten ist der test mit 6 enums Konstanten:

package t1;

public class ZEnums {

    public enum MyEnum {
  A { boolean getBooleanValue(){ return true; }},
  B { boolean getBooleanValue(){ return true; }},
  C { boolean getBooleanValue(){ return false; }},
  D { boolean getBooleanValue(){ return false; }},
  E { boolean getBooleanValue(){ return false; }},
  F { boolean getBooleanValue(){ return false; }}, 

  ;
  abstract boolean getBooleanValue();
  }

  public enum MyEnumAlt {
    A (true), 
    B (true),
    C (false),
    D (false),
    E (false),
    F (false),
    ;
    private final boolean isTrue;
    MyEnumAlt( boolean isTrue){ this.isTrue = isTrue; }
    boolean getBooleanValue(){ return isTrue; };
  }

  public static void main(String[] args) {
    log("Warming up...");
    //10k iterations won't do since not all paths for MyEnum are invoked 10k (default) times to warrant compilations 
    long warmum = testEnum(100000 )+ testAlt(100000)+testEnum(100000 )+ testAlt(100000);
    log("Warm up: %d", warmum);     
    //no info from +XX:+PrintCompilation below this one, or the test is invalid
    testMain();

    }
    public static void testMain() {
        int iterations = (int)4e7;

        log("Testing %d iterations%n", iterations);
        log("====");

        log("Testing with Overridden method...");       
    System.gc();
    {
    long start = System.currentTimeMillis();
    long len = 0;
    len = testEnum(iterations);
    long time = System.currentTimeMillis()-start;
    log("Overridden method version took %dms, length: %d ", time, len);
    }
////////////
    System.gc();
    {
    log("Testing with Constant in c-tor... ");
    long start = System.currentTimeMillis();
    long len = testAlt(iterations);

    long time = System.currentTimeMillis()-start;
    log("Constant in c-tor version took %dms, length: %d ", time, len);
    }
    }
    private static long testEnum(int iterations) {
        long len = 0;
        for(int i=0; i<iterations; i++){
        MyEnum tmpEnum = MyEnum.A;
        if(i%3==0){ tmpEnum = MyEnum.A;        
        }else if(i%4==0){ tmpEnum = MyEnum.B;
        }else if(i%5==0){ tmpEnum = MyEnum.C;
        }else if(i%6==0){ tmpEnum = MyEnum.D;
        }else if(i%6==0){ tmpEnum = MyEnum.E;
        }else{ tmpEnum = MyEnum.F; 
        }
        String tmp = tmpEnum.getBooleanValue()?"XXX":"ABCDE";
        len+=tmp.length();
    }
        return len;
    }
    private static long testAlt(int iterations) {
        long len =0;
        for(int i=0; i<iterations; i++){
        MyEnumAlt tmpEnum = MyEnumAlt.A;
        if(i%3==0){ tmpEnum = MyEnumAlt.A;
        }else if(i%4==0){ tmpEnum = MyEnumAlt.B;
        }else if(i%5==0){ tmpEnum = MyEnumAlt.C;
        }else if(i%6==0){ tmpEnum = MyEnumAlt.D;
        }else if(i%6==0){ tmpEnum = MyEnumAlt.E;
        }else{ tmpEnum = MyEnumAlt.F; 
        }
        String tmp = tmpEnum.getBooleanValue()?"XXX":"ABCDE";
        len+=tmp.length();
    }
        return len;
    }
    static void log(String msg, Object... params){ 
        String s = params.length>0?String.format(msg, params):msg;
        System.out.printf("%tH:%<tM:%<tS.%<tL %s%n", new Long(System.currentTimeMillis()), s);
    }
}

21:08:46.685 Aufwärmen... 
148 1% t1.ZEnums::testEnum @ 7 (125 Byte) 
150 1 t1.ZEnums$MyEnum$6::getBooleanValue (2 bytes) 
152 2 t1.ZEnums$MyEnum$1::getBooleanValue (2 bytes) 
154 3 t1.ZEnums$MyEnum$2::getBooleanValue (2 bytes) 
155 4 t1.ZEnums$MyEnum$3::getBooleanValue (2 bytes) 
158 2% t1.ZEnums::testAlt @ 7 (125 Byte) 
162 5 t1.ZEnums::testEnum (125 Byte) 
164 6 t1.ZEnums::testAlt (125 Byte) 
21:08:46.716 Warm-up: 1600000 
21:08:46.716 Testen 40000000 Iterationen 

21:08:46.716 ==== 
21:08:46.716 Tests mit Überschriebenen Methode... 
21:08:47.513 Überschriebene Methode-version nahm 781ms, Länge: 160000000 
21:08:47.513-Test mit Konstante in c-tor... 
21:08:48.138 Konstante in c-tor-version nahm 625ms, Länge: 160000000

War der code ausgeführt w/-server -XX:+PrintCompilation Optionen.
Der Unterschied ist nicht riesig, natürlich. Aber das ist nicht die interessante Frage. Wenn Sie testen die version mit 2 enum-Konstanten-obwohl, das Ergebnis kann erheblich unterschiedlich sein. Für 2-Aufruf von Websites erzeugt der compiler den code von inlinining die Methode in Frage. In dem test oben, die entfernen würde, gesamte Aufruf booleanValue und können sogar führen Sie den test in O(1).

Den lustigsten Teil geht jedoch von 2 bis 3 enum-Konstanten, wenn der compiler gestartet wird die Verwendung von inline caches und dann die Konstante, und WOW Magie, das alles verändert.

Die Quintessenz ist: die geeignete benchmark ist wirklich schwer und erfordert einige Kenntnisse, wie der JIT-kompiliert, wenn der GC könnte ein Problem sein (entweder entfernen oder Sie zu umarmen) und so weiter.

Links:

InformationsquelleAutor

verwenden Sie einfach den enum-Konstanten:

MyEnum variable;
...
switch ( variable ) {
    case A:
        return true;
    case B:
        return true;
    default:
        return false;
}

vorausgesetzt, so etwas wie:

public enum MyEnum {
    A, B
}

aber hüten Sie sich vor NullPointerException (wenn variable ist null)

InformationsquelleAutor Carlos Heuberger

1

Was Sie Fragen ist wohl:
Wenn Sie die Schalter in einer Methode im enum selbst:
```
switch ( this )
        {
        case A:
            return true;
        case B:
            return true;
        default:
            return false;
        }
```
Und in einer anderen Klasse:
```
switch ( variable )  //Variable of type myEnum
        {
        case A:
            return true;
        case B:
            return true;
        default:
            return false;
        }
```
Es ist leicht zu vergessen, ein update der switch-Anweisungen wenn Sie weitere hinzufügen, enum, also eine bessere Wette wäre, legen Sie die Methoden, wie dies in den enum selbst und verwenden Sie Konstanten-spezifische Implementierungen von Methoden:
```
public enum MyEnum
    A { boolean getBooleanValue(){ return true; },
    B { boolean getBooleanValue(){ return true; },
    C { boolean getBooleanValue(){ return false; };
    abstract boolean getBooleanValue();
}
```
Diese Weise, wenn Sie jemals fügen Sie ein neues enum-Wert, der compiler wird Sie daran erinnern, erklären die getBooleanValue Methode und verwenden Sie einfach A.getBooleanValue(); wo Sie es brauchen.

Als wurde darauf hingewiesen, in den Kommentaren, eine andere option ist diese:
```
public enum MyEnumAlt {
    A (true), 
    B (true),
    C (false);
    private final boolean isTrue;
    MyEnumAlt( boolean isTrue){ this.isTrue = isTrue; }
    boolean getBooleanValue(){ return isTrue; };
}
```
Es ist eine Frage der Präferenz und abhängig von der jeweiligen situation ab. Wenn Sie einfach zurückgeben eines Wertes für jede enum-der Konstruktor-version ist plausibel, aber ich finde es weniger lesbar. Bedenken über dieses besser ist unbegründet, wie Sie sehen können, Sie zu testen:
```
public void testMain() {
        System.out.println("Testing with constructor: ");
        long start = System.currentTimeMillis();
        for(int i=0; i<1000*1000; i++){
            MyEnum tmpEnum = null;
            if(i%3==0){ tmpEnum = MyEnum.A;
            }else if(i%4==0){ tmpEnum = MyEnum.B;
            }else{ tmpEnum = MyEnum.C; }
            String tmp = Integer.toString(i)+" "+tmpEnum.getBooleanValue();
        }
        long time = System.currentTimeMillis()-start;
        System.out.println("Constructor version took "+time);

        System.out.println("Testing with Constant specific method implementation: ");
        long start2 = System.currentTimeMillis();
        for(int i=0; i<1000*1000; i++){
            MyEnumAlt tmpEnum2 = null;
            if(i%3==0){ tmpEnum2 = MyEnumAlt.A;
            }else if(i%4==0){ tmpEnum2 = MyEnumAlt.B;
            }else{ tmpEnum2 = MyEnumAlt.C; }
            String tmp2 = Integer.toString(i)+" "+tmpEnum2.getBooleanValue();
        }
        long time2 = System.currentTimeMillis()-start2;
        System.out.println("Constant specific method version took "+time2);
    }
```
- Natürlich, Sie müssen im Hinterkopf behalten, dass ein Wechsel auf die enum-Werte sind nicht die beste Idee, denn es ist nicht leicht zu pflegen dieser code. Wenn Sie fügen Sie ein neues enum-Wert, die Sie benötigen, zu erinnern, zu aktualisieren alle switch-Anweisungen...
- hinzufügen von Funktionen wie in der Enum ist kontraproduktiv. 1.: Sie wären besser dran, wenn Sie eine eigene boolean-Feld und c-tor, das initialisiert die enum (sieht mal besser und es ist besser Leistung klug - Speicher/Zeit, jede Konstante, wie dies zu einer neuen Klasse); 2. hinzufügen von mehr Fällen (Funktionen), die abhängig von der enum erfordert eine änderung des Domänen-Modell, zum Beispiel, wenn Sie brauchen eine andere Funktion zurückgibt, boolean. Der Kerl braucht nur ein EnumSet.
- Es würde davon abhängen, die situation. Wenn es so einfach ist die Rücksendung einen bestimmten Wert, dann ja, können Sie einfach einen Konstruktor und Feld, aber es würde sehr ähnlich Aussehen, um diese in jedem Fall. In Bezug auf Leistung, Es gibt immer nur eine Instanz von jedem enum-Feld und der hotspot-compiler in die-Innenfutter die meisten der code, so würde ich argumentieren, dass dieser code wäre besser, als zu versuchen, code, der die Funktionalität in eine Methode außerhalb der enum. Den Unterschied in der Leistung in jedem Fall wäre so gering, dass es nicht einen Unterschied machen für 99,9% der Fälle in jedem Fall.
- Und in der Tat stellt sich heraus, dass ich Recht habe. Test, weist eine Millionen enums und erstellt eine Zeichenfolge, die aus Ihnen in einer Schleife (das läuft eine Millionen mal): Konstruktor-version nahm 268 ms Konstante spezifische Methode version nahm 232 ms
- Ich bin sehr viel Angst vor der benchmark ist irgendwie noch ein anderes micro-bencmark-nicht-habe-Recht. Die benchmark muss warmup, da die Art, wie es gemacht wird, es enthält die compilation-Zeit. Auch der 2. test ist wahrscheinlich, um einige der garbage collection. btw, MyEnum nicht kompiliert werden kann. Ich habe schreiben die benchmark, die Konstanten, die ist etwas schneller auf 40M Elemente, die benchmarks verbringt die meisten, wenn die Zeit, in der Modul-und der String-Erstellung, so müssen die sehr viele Auswirkungen hat.
- Nicht-sound-offensive, auch die Industrie-standard-benchmarks sind oft aus-der-mark: azulsystems.com/events/javaone_2002/microbenchmarks.pdf
InformationsquelleAutor Riaan Cornelius

Eine bessere Lösung wäre so etwas wie dieses:

enum:

public interface ACServices {

    public static enum MessageType {

        //periodic needs to saved in DB
        PIPE_INFO_TYPE_AC_DEVICE_LIST, //periodic from littlecloud
        PIPE_INFO_TYPE_DEV_ONLINE,
        PIPE_INFO_TYPE_DEV_OFFLINE,
        PIPE_INFO_TYPE_EVENT_LOG,
        PIPE_INFO_TYPE_DEV_DETAIL,
    };

Umsetzung:

ACServices.MessageType msgType = ACServices.MessageType.valueOf(acResponse.getType());
switch (msgType){
    case INT_INFO_DEV_STATUS:
        break;
    case INT_INFO_DEV_TZ:
        break;
    case PIPE_INFO_DEV_COUNT:
        break;
    case PIPE_INFO_TYPE_AC_DEVICE_LIST:
        break;
    case PIPE_INFO_TYPE_CONFIG_GET_TEXT:
        break;
    default:
        break;
}

Mann Pak Hong, Dave ([email protected])

InformationsquelleAutor user3615372

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.