Podzielić duże wyliczenie Java

Question

Jaka jest zalecana praktyka w przypadku wyliczenia Java, które ma wartości 1300 i umieszczenie go w zorganizowanych grupach? Wiem, że nie można po prostu rozszerzyć grupy enum, więc czy istnieją inne dobre alternatywy?

Answer 1

Korzystałbym z interfejsu, który wszystkie te instancje współdzielą, następnie można użyć dowolnej liczby wyliczeń lub załadować je z innego źródła danych, takiego jak plik lub baza danych.

Answer 2

Z perspektywy optymalizacji, dobrym pomysłem byłoby podzielenie ich na spójne jednostki. Gdybym był tobą, oceniłbym, które z tych wyrażeń mają spójność w kierunku odpowiedzialności.

Answer 3

1300 wartości? Dobry Boże, który pomyślał, że to dobry pomysł? Czy nie przyszło to komuś po 100, że robiło się za duże?

Nie ma dobrego sposobu obejścia tego, co mogę zobaczyć. Zdobądź łopatę i zacznij łączyć je w bardziej spójne podgrupy.

Oto pytanie: w jaki sposób są używane? Jeśli są one częścią konfiguracji aplikacji, zaleciłbym przeniesienie ich do bazy danych zamiast trzymania ich w kodzie. W ten sposób będą bardziej elastyczni.

Answer 4

można złamać je jak:

import java.util.*; 
interface Children { 
    Set<Enum<?>> children(); 
} 
enum Dog implements Children { 
    myDog,yourDog; 
    Dog() { 
     this(null); 
    } 
    Dog(Set<Enum<?>> children) { 
     this.children=children; 
    } 
    @Override public Set<Enum<?>> children() { 
     return children!=null?Collections.unmodifiableSet(children):null; 
    } 
    Set<Enum<?>> children; 
} 
enum Animal implements Children { 
    cat,dog(EnumSet.allOf(Dog.class)); 
    Animal() { 
     this(null); 
    } 
    Animal(Set children) { 
     this.children=children; 
    } 
    @Override public Set<Enum<?>> children() { 
     return children!=null?Collections.unmodifiableSet(children):null; 
    } 
    Set<Enum<?>> children; 
} 
enum Thing implements Children { 
    animal(EnumSet.allOf(Animal.class)),vegetable,mineral; 
    Thing() { 
     this(null); 
    } 
    Thing(Set children) { 
     this.children=children; 
    } 
    @Override public Set<Enum<?>> children() { 
     return children!=null?Collections.unmodifiableSet(children):null; 
    } 
    Set<Enum<?>> children; 
} 
public class So8671088 { 
    static void visit(Class<?> clazz) { 
     Object[] enumConstants = clazz.getEnumConstants(); 
     if (enumConstants[0] instanceof Children) for (Object o : enumConstants) 
      visit((Children) o, clazz.getName()); 
    } 
    static void visit(Children children, String prefix) { 
     if (children instanceof Enum) { 
      System.out.println(prefix + ' ' + children); 
      if (children.children() != null) for (Object o : children.children()) 
       visit((Children) o, prefix + ' ' + children); 
     } else 
      System.out.println("other " + children.getClass()); 
    } 
    public static void main(String[] args) { 
     visit(Thing.animal," "); 
     visit(Thing.class); 
    } 
}