订购枚举值(Ordering enum values)

我在想，如果有订货枚举不同类别的任何方式。 如果例如，我有以不同的方式反应，以其他化学品，一些强，中弱的化学品的一个固定基团。 我基本上要能够切换向上其中它们取决于组是应该进行反应的化学排列的次序（即，取决于类）。 我知道我应该使用对比，但我不知道该怎么做。 如果我不够清晰，发表评论，我会进一步解释。

谢谢。

public static enum Chem {
    H2SO4, 2KNO3, H20, NaCl, NO2
};

所以，我有东西，看起来像这一点，我已经知道如何每种化学会到一些其他化学物质发生反应。 我只是希望在此基础上与将要反应的化学安排CHEMS。 这几乎是我的全部。

Answer 1:

实现不同的Comparator的（见http://docs.oracle.com/javase/6/docs/api/java/util/Comparator.html ）

Comparator comparator1 = new Comparator<MyEnum>() {

  public int compare(MyEnum e1, MyEnum e2) {
     //your magic happens here
     if (...)
       return -1;
     else if (...)
       return 1;

     return 0;
  }
};

//and others for different ways of comparing them

//Then use one of them:
MyEnum[] allChemicals = MyEnum.values();
Arrays.sort(allChemicals, comparator1); //this is how you sort them according to the sort critiera in comparator1.

Answer 2:

这里是表示你根据不同的标准来分类的枚举的相同的值的示例：

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortEnum {

    public enum TestEnum {
        A(1, 2), B(5, 1), C(3, 0);
        private int value1;
        private int value2;

        private TestEnum(int value1, int value2) {
            this.value1 = value1;
            this.value2 = value2;
        }

        public int getValue1() {
            return value1;
        }

        public int getValue2() {
            return value2;
        }
    }

    public static void main(String[] args) {
        List<TestEnum> list = Arrays.asList(TestEnum.values());
        System.err.println(list);
        Collections.sort(list, new Comparator<TestEnum>() {
            @Override
            public int compare(TestEnum o1, TestEnum o2) {
                return o1.getValue1() - o2.getValue1();
            }
        });
        System.err.println(list);
        Collections.sort(list, new Comparator<TestEnum>() {
            @Override
            public int compare(TestEnum o1, TestEnum o2) {
                return o1.getValue2() - o2.getValue2();
            }
        });
        System.err.println(list);
    }
}

输出是

[A，B，C] [A，C，B] [C，B，A]

Answer 3:

你可以把尽可能多的比较中，只要你喜欢，见下面的例子枚举：

import java.util.Comparator;

public enum Day {
    MONDAY(1, 3),
    TUESDAY(2, 6),
    WEDNESDAY(3, 5),
    THURSDAY(4, 4),
    FRIDAY(5, 2),
    SATURDAY(6, 1),
    SUNDAY(0, 0);

    private final int calendarPosition;
    private final int workLevel;

    Day(int position, int level) {
      calendarPosition = position;
      workLevel = level;
    }

    int getCalendarPosition(){ return calendarPosition; }  
    int getWorkLevel() { return workLevel;  }

    public static Comparator<Day> calendarPositionComparator = new Comparator<Day>() {
      public int compare(Day d1, Day d2) {
        return d1.getCalendarPosition() - d2.getCalendarPosition();
      }
    };

    public static Comparator<Day> workLevelComparator = new Comparator<Day>() {
      public int compare(Day d1, Day d2) {
        // descending order, harder first
        return d2.getWorkLevel() - d1.getWorkLevel();
      }
    };
}

在行动中看到的比较：

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class EnumDayTest
{
  public static void main (String[] args) {
     List<Day> allDays = Arrays.asList(Day.values());
     System.out.println("===\nListing days in order of calendar position:");
     Collections.sort(allDays, Day.calendarPositionComparator);
     showItems(allDays);
     System.out.println("===\nListing days in order of work level:");
     Collections.sort(allDays, Day.workLevelComparator);
     showItems(allDays);
  }

  public static void showItems(List<Day> days) {
    for (Day day : days) {
      System.out.println(day.name());
    }
  }
}

Answer 4:

假设你有元素的枚举：

enum Elements {Oxygen, Hydrogen, Gold}

你想他们在一个给定的顺序进行排序，然后我可以这样做：

Elements[] myElements = Elements.values();
Arrays.sort(myElements, new ElementComparator());

其中ElementComparator可以是这样的：

public class ElementComparator implements java.util.Comparator<Elements> {
    public int compare(Elements left, Elements right){
        return right.compareTo(left); //use your criteria here
    }
}

的排序标准的性质是不是在你的问题清楚。 好像它是关于化学反应相关的东西。 我想，标准应该在去Comparator ，以决定哪些枚举元素比给定的化学反应的其他较大。

Answer 5:

你的意思是代表你的化学品枚举实际的对象？ 这sooooounds是一个奇怪的实现，如果我可以这样说：枚举真的是更适合的东西“属性”。

但无论如何...如果你真的想代表他们的枚举，然后对它们进行排序，我建议implemeting一个比较，可以整理你的特定类型的枚举，然后在它的compare（）方法，进行相应的比较，如：

Comparator<Chemical> comp = new Comparator<Chemical>() {
    public int compare(Chemical o1, Chemical o2) {
        if (o1.reactivity() > o2.reactivity()) {
          return 1;
        } else if (o1.reactivity() < o2.reactivity()) {
          return -1;
        } else {
        return integer depending on whatever else you want to order by...
        }
    }
};

然后，你可以到排序的方法通过这一比较，有序集合构造等参与其中。

您可以扩展您的枚举子类包括任何额外的方法，如反应性（），您需要。

文章来源: Ordering enum values