Wie Sortiere ich die enum-Mitglieder in alphabetischer Reihenfolge in Java?

Dachte ich, dass die Werte () - Methode würde mir eine bestellt Ansicht des enum (wie hier erwähnt), aber das ist hier nicht der Fall. Ich habe einfach die enum-Mitglieder in der Reihenfolge in der ich Sie erstellt in dem Brief enum-Klasse.

Genau, die Reihenfolge der Deklaration als signifikant für enums, also wir sind froh, dass Sie zurückgegeben werden, in genau dieser Reihenfolge. Zum Beispiel, wenn ein int i stellt eine enum-Werte, dabei values()[i] ist eine sehr einfache und effiziente Weise zu finden, die enum-Instanz. Gehen entgegen-Weise, die ordinal() - Methode gibt den index eines enum-Instanz.

Gibt es eine Möglichkeit, um die Ausgabe der Werte eines enum in alphabetischer Reihenfolge? Brauche ich einen separaten Komparator-Objekt, oder ist es eine integrierte Möglichkeit, dies zu tun? Grundsätzlich würde ich gerne die Werte werden alphabetisch sortiert, basierend auf der getDescription () - text:

Was Sie nennen Wert ist nicht etwas, was definiert für Enumerationen im Allgemeinen. Hier, in Ihrem Kontext, die Sie bedeuten, das Ergebnis des getDescription().

Wie Sie sagen, könnten Sie erstellen Sie einen Komparator für diese Beschreibungen. Das wäre perfekt 🙂

Beachten Sie, dass im Allgemeinen, Sie brauchen könnten mehrere Aufträge für diese Fälle:

• in der Reihenfolge der Deklaration (dies ist die offizielle Reihenfolge)
• Beschreibung, um
• anderen als

Könnten Sie auch drängen, dass die Vorstellung von DescriptionComparator ein wenig:

1. Aus Gründen der Leistung, die Sie speichern könnte die berechnete Beschreibungen.

2. Weil enums können nicht Erben, die die Wiederverwendung von code muss außerhalb der enum-Klasse. Lassen Sie mich das Beispiel verwenden wir in unseren Projekten:

Nun die code-Beispiele...

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

Beachten Sie, dass die generischen code in EnumUtils funktioniert nicht nur für ein enum-Klasse, aber funktioniert für jede enum-Klasse in Ihr Projekt implementiert, dass das Described Schnittstelle.

Wie gesagt, der Punkt, der mit dem code außerhalb des enums (wo es sonst gehören) ist es, den code wiederverwenden. Es ist keine große Sache für zwei enums, aber wir haben über tausend Enumerationen, die in unserem Projekt, viele von Ihnen mit den gleichen Schnittstellen...!

InformationsquelleAutor KLE

Hier ist eine generische Art und Weise, es zu tun mit jeder Klasse ohne Implementierung Vergleichbar auf die Klasse, die Sie sind, Sortieren oder erstellen Sie eine benutzerdefinierte Komparator. Ich habe gefunden Instanzen, wo ich nicht überschreiben wollen compareTo denn es dient einem anderen Zweck, Sie können nicht für Enumerationen sowieso, und ständig erstellen von wrapper-Klassen ist ein Schmerz. Sie können übergeben Sie eine Funktion, die Ausgänge ein Vergleichbares Objekt, das Sie verwenden möchten für Sortier-Zwecke.

Den toComparable Funktion wird nur aufgerufen, einmal pro element in der Liste (nicht so für eine benutzerdefinierte Komparator), so ist es besonders gut, wenn dieser Aufruf ist teuer für einige Klassen. Null-Werte werden intern abgewickelt, so dass es einfacher zu bedienen als eine benutzerdefinierte Komparator. Ein Aufruf von Java 7 ist TimSort Algorithmus wesentlich effizienter als ein Haufen von O(log N) INSERT, um eine SortedMap (rot-schwarz-Baum oder anderen balancierten Baum-Implementierung). Und Sie sind nicht beschränkt auf eine bestimmte Klasse oder ein interface.

Real world performance steigt signifikant sind, in vielen Fällen. Zum Beispiel, die performance-Steigerung ist etwa 5x so schnell wie mit einem Komparator beim Sortieren Doppelzimmer mit toString() auf eine Liste der Größe 100k.

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

InformationsquelleAutor pscuderi