如何在Java中按字母顺序对枚举成员排序？

我有一个enum类，如下所示：

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

随后，我在代码中基本上迭代字母enum，并将其成员打印到控制台：

for (Letter letter : Letter.values()) {
System.out.println(letter.getDescription());
}

我原以为values（）方法会为我提供枚举的有序视图（如前所述），但这里的情况并非如此。我只是按照我在Letter enum类中创建的顺序获取枚举成员。有没有办法按字母顺序输出枚举值？我是否需要一个单独的比较器对象，或者是否有一种内置的方法来实现这一点？基本上，我希望这些值根据getDescription（）文本按字母顺序排序：

---

只需使用Arrays.sort和您自己的比较器对它们进行排序。

SortedMap=newtreemap（）；
SortedMap<String, Letter> map = new TreeMap<String, Letter>();
for (Letter l : Letter.values()) {
    map.put(l.getDescription, l);
}
return map.values();

for（字母l:Letter.values（））{
map.put（l.getDescription，l）；
}
返回map.values（）；

或者只需重新排序声明：-）

编辑：正如KLE指出的，这假设描述在枚举中是唯一的

我认为values（）方法会给我一个枚举的有序视图（如这里所提到的），但这里的情况并非如此。我只是按照我在Letter enum类中创建的顺序获取枚举成员

确切地说，声明的顺序对于enum来说是重要的，因此我们很高兴它们是按照这种顺序返回的。例如，当

int i

表示枚举值时，执行

values（）[i]

是查找枚举实例的一种非常简单有效的方法。相反，

ordinal（）

方法返回枚举实例的索引

有没有办法按字母顺序输出枚举值？我是否需要一个单独的比较器对象，或者是否有一种内置的方法来实现这一点？基本上，我希望这些值根据getDescription（）文本按字母顺序排序：

通常，您所称的值不是为枚举定义的。这里，在您的上下文中，您指的是

getDescription（）

的结果

正如您所说，您可以为这些描述创建一个比较器。那太好了：-）

---

请注意，一般来说，这些实例可能需要几个订单：

• 申报单（这是官方订单）
• 描述顺序
• 其他需要的

---

您还可以稍微推广一下DescriptionComparator的概念：

出于性能原因，您可以存储计算的描述

因为枚举不能继承，所以代码重用必须在枚举类之外。让我举一个我们将在项目中使用的例子：

现在代码示例

/** 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);

/**用于具有说明的枚举的接口*/
描述的公共接口{
/**返回描述*/
字符串getDescription（）；
}
描述了公共枚举{
//..执行情况与原岗位相同，
//因为这个方法已经实现了
}
公共枚举描述的其他实现{
//……一样
}
/**枚举的实用程序*/
公共抽象类枚举{
/**描述对象的可重用比较器实例*/
公共静态比较器描述\u比较器=
新比较器（）{
公共整数比较（描述a、描述b）{
返回a.getDescription（）.compareTo（b.getDescription）；
}
};
/**返回枚举的已排序描述*/
公共静态列表
getSortedDescriptions（类enumClass）{
列表描述=新建ArrayList（）；
对于（E:enumClass.getEnumConstants（））{
result.add（e.getDescription（））；
}
收集.分类（说明）；
返回说明；
}
}
//呼叫方代码
列表字母=EnumUtils.getSortedDescriptions（Letter.class）；
List others=EnumUtils.getSortedDescriptions（Other.class）；

请注意，

EnumUtils

中的泛型代码不仅适用于一个enum类，而且适用于项目中实现所述

接口的任何enum类

如前所述，将代码放在枚举之外（否则它将属于枚举）的目的是重用代码。对于两个枚举来说这没什么大不了的，但是我们的项目中有上千个枚举，其中许多具有相同的接口
 这里有一种通用的方法，可以对任何类执行此操作，而无需在正在排序的类上实现Compariable或创建自定义比较器。我发现我不想覆盖compareTo的实例，因为它有不同的用途，你无论如何不能覆盖枚举，不断地创建包装类是一件痛苦的事情。您可以传入一个函数，该函数输出一个用于排序的可比较对象

对于列表中的每个元素，toComparable函数只调用一次（对于自定义比较器不是这样），因此，如果调用对于某些类来说代价高昂，那么它尤其有用。空值是在内部处理的，因此它比自定义比较器更易于使用。对Java7的TimSort算法的一次调用比对SortedMap（红黑树或其他平衡树实现）进行一系列O（logn）插入要高效得多。而且您不局限于任何特定的类或接口

在许多情况下，真实世界的性能提高是显著的。例如，当使用toString（）对大小为100k的列表进行双倍排序时，性能的提高大约是使用比较器的5倍

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

import java.util.ArrayList；
导入java.util.array；
导入java.util.Collections；
导入java.util.List；
导入java.util.ListIterator；
公共类泛型分类器{
公开信{
欧米茄字母（“欧米茄”），
伽马字母（“伽马”），
贝塔字母（“贝塔”），
阿尔法字母（“阿尔法”）；
私有最终字符串描述；
信（）{
description=toString（）；
}
字母（字符串描述）{
这是我的名字
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);
       }
    }
}