Comment trier les membres d'enum par ordre alphabétique en Java?

Je pensais que les valeurs de() la méthode pourrait me donner un ordre de vue de l'enum (comme indiqué ici), mais ce n'est pas le cas ici. J'ai tout simplement obtenir l'énumération des membres dans l'ordre que j'ai créé dans la Lettre enum class.

Précisément, l'ordre de déclaration est considérée comme significative pour les enums, donc nous sommes heureux qu'ils sont retournés là, dans l'ordre. Par exemple, lorsqu'un int i représente une des valeurs enum, faire values()[i] est un moyen très simple et efficace pour trouver l'enum instance. Aller à l'encontre des sages, le ordinal() méthode renvoie l'index d'un enum instance.

Est-il un moyen de sortie les valeurs d'une énumération dans l'ordre alphabétique? Ai-je besoin d'une référence distincts de l'objet, ou est-il intégré dans la façon de le faire? Fondamentalement, je voudrais les valeurs qui doivent être triés par ordre alphabétique basé sur la getDescription() texte:

Ce que vous appelez valeur n'est pas quelque chose de défini pour les enums en général. Ici, dans votre contexte, vous dire que le résultat de getDescription().

Comme vous le dites, vous pourriez créer un Comparateur pour ces descriptions. Qui serait parfait 🙂

---

Remarque qu'en général, vous pourriez avoir besoin de plusieurs ordres de ces instances:

• ordre de déclaration (c'est l'ordre officiel)
• description afin
• d'autres si nécessaire

---

Vous pouvez aussi pousser la notion de DescriptionComparator un peu:

1. Pour des raisons de performances, vous pouvez stocker le résultat de descriptions.

2. Parce que les énumérations peuvent pas hériter, la réutilisation de code doit être à l'extérieur de la classe enum. Permettez-moi de donner l'exemple nous utilisons dans nos projets:

Maintenant les exemples de code...

/** Interface for enums that have a description. */
public interface Described {
  /** Returns the description. */
  String getDescription();
}

public enum Letter implements Described {
  //.... implementation as in the original post, 
  //as the method is already implemented
}

public enum Other implements Described {
  //.... same
}

/** Utilities for enums. */
public abstract class EnumUtils {

  /** Reusable Comparator instance for Described objects. */
  public static Comparator<Described> DESCRIPTION_COMPARATOR = 
    new Comparator<Described>() {
      public int compareTo(Described a, Described b) {
        return a.getDescription().compareTo(b.getDescription);
      }
    };

  /** Return the sorted descriptions for the enum. */
  public static <E extends Enum & Described> List<String> 
    getSortedDescriptions(Class<E> enumClass) {
      List<String> descriptions = new ArrayList<String>();
      for(E e : enumClass.getEnumConstants()) {
        result.add(e.getDescription());
      }
      Collections.sort(descriptions);
      return descriptions;
  }
}

//caller code
List<String> letters = EnumUtils.getSortedDescriptions(Letter.class);
List<String> others = EnumUtils.getSortedDescriptions(Other.class);

Noter que le générique de code dans EnumUtils ne travaille pas seulement pour un enum class, mais fonctionne pour n'importe quel enum classe dans votre projet met en œuvre la Described interface.

Comme dit avant, le point d'avoir le code en dehors de la énumérations (où il serait autrement appartiennent) est de réutiliser le code. Ce n'est pas une grosse affaire pour les deux énumérations, mais nous avons plus d'un millier d'énumérations dans notre projet, beaucoup d'entre eux avec les mêmes interfaces...!

Voici un générique façon de le faire avec toute la classe, sans avoir à mettre en œuvre Comparable sur la classe que vous soyez de tri ou de créer un comparateur. J'ai trouvé des cas où je ne veux pas remplacer compareTo parce qu'elle sert un but différent, vous ne pouvez pas pour les énumérations, de toute façon, et ne cesse de créer des classes wrapper est une douleur. Vous pouvez passer d'une fonction qui génère un Comparable de l'objet que vous souhaitez utiliser à des fins de tri.

La toComparable fonction n'est appelée qu'une fois par élément dans la liste (pas tellement pour une mesure de comparaison), il est donc particulièrement bonne si cet appel est cher pour un peu de classe. Les valeurs Null sont gérées en interne, de sorte qu'il est plus facile à utiliser qu'une coutume comparateur. Un appel à Java 7 TimSort algorithme est considérablement plus efficace que de faire un tas de O(log N) insère un SortedMap (rouge-noir arbres ou d'autres équilibrée de l'arbre de la mise en œuvre). Et vous n'êtes pas limités à un particulier de la classe ou de l'interface.

Monde réel augmente les performances sont importantes dans de nombreux cas. Par exemple, l'augmentation de la performance est d'environ 5x aussi rapide que d'utiliser un comparateur de tri de Doubles à l'aide de toString() sur une liste de taille 100.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
public class GenericLetterSorter {
public enum Letter {
OMEGA_LETTER("Omega"), 
GAMMA_LETTER("Gamma"), 
BETA_LETTER("Beta"), 
ALPHA_LETTER("Alpha"); 
private final String description;
Letter() {
description = toString();
}
Letter(String description) {
this.description = description;
}
public String getDescription() {
return description;
}
}
public static void main(String[] args) {
List<Letter> list = new ArrayList<>(Arrays.asList(Letter.values()));
sort(list, new ToComparable<Letter>() {
@Override
public Comparable toComparable(Letter letter) {
//sort based on the letter's description
return letter == null ? null : letter.getDescription();
}
});
for (Letter letter : list)
System.out.println(letter == null ? null : letter.name());
}
public interface ToComparable<T, C extends Comparable<? super C>> {
C toComparable(T t);
}
public static <T, C extends Comparable<? super C>> void sort(List<T> list, ToComparable<T, C> function) {
class Pair implements Comparable<Pair> {
final T original;
final C comparable;
Pair(T original, C comparable) {
this.original = original;
this.comparable = comparable;
}
@Override
public int compareTo(Pair other) {
return
comparable == null && other.comparable == null ? 0 :
comparable == null ? -1 :
other.comparable == null ? 1 :
comparable.compareTo(other.comparable);
}
}
List<Pair> pairs = new ArrayList<>(list.size());
for (T original : list)
pairs.add(new Pair(original, function.toComparable(original)));
Collections.sort(pairs);
ListIterator<T> iter = list.listIterator();
for (Pair pair : pairs) {
iter.next();
iter.set(pair.original);
}
}
}