Pensé que el método values () me daría una vista ordenada de la enumeración (como se menciona aquí), pero este no es el caso aquí. Simplemente obtengo los enumeradores en el orden en que los creé dentro de la clase Letter enum.
Precisamente, el orden de la declaración se considera significativo para las enumeraciones, por lo que nos complace que se devuelvan exactamente en ese orden. Por ejemplo, cuando un int i representa valores enum, hacer values()[i] es una forma muy simple y eficiente de encontrar la instancia enum. Para ir en sentido contrario, el método ordinal() devuelve el índice de una instancia enum.
¿Hay alguna manera de mostrar los valores de una enumeración en orden alfabético? ¿Necesitaría un objeto de comparación por separado o hay una forma incorporada de hacerlo? Básicamente me gustaría que los valores a ser ordenada alfabéticamente basadas en el texto getDescription():
Lo que llamas valor no es algo definido para las enumeraciones en general. Aquí, en su contexto, se refiere al resultado de getDescription().
Como dices, podrías crear un Comparador para estas descripciones.Eso sería perfecto :-)
Tenga en cuenta que, en general, que pueda necesitar varios pedidos para estos casos:
- orden de la declaración (este es el orden oficial)
- Descripción fin
- otras según sea necesario
También podría empujar esa noción de DescriptionComparator un poco:
Por motivos de rendimiento, se podría almacenar las descripciones calculados.
Porque las enumeraciones no pueden heredar, la reutilización del código debe estar fuera de la clase enum. Permítanme dar el ejemplo usaríamos en nuestros proyectos:
Ahora los ejemplos de código ...
/** 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);
Tenga en cuenta que el código genérico en EnumUtils funciona no sólo para una clase de enumeración, pero funciona para cualquier clase enum en su proyecto que implemente la interfaz Described.
Como dijimos antes, el objetivo de tener el código fuera de las enumeraciones (donde pertenecería de otro modo) es reutilizar el código. No es gran cosa para dos enumeraciones, pero tenemos más de mil enums en nuestro proyecto, muchos de ellos con las mismas interfaces ...!
El artículo que enlaza no es incorrecto. El orden al que se refiere es la secuencia en la que fueron escritos en la enumeración. El compilador/tiempo de ejecución no hace ninguna clasificación especial en los valores enum. – Suppressingfire
Encontré este enlace aquí en stackoverflow y me funcionó. http://stackoverflow.com/a/18416259/6301287 –