Java 对枚举值排序

我想知道是否有任何方法可以对不同类的枚举进行排序。例如，我有一组固定的化学物质，它们以不同的方式与其他化学物质发生反应，有些强，有些弱。我基本上希望能够根据基团反应的化学物质（也就是说，根据类别），改变它们的排列顺序。我知道我应该使用Comparable，但我不知道如何使用它。如果我不够清楚，请留下评论，我将进一步解释

谢谢

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

---

我已经知道了每种化学物质对其他化学物质的反应。我只是想根据它与之反应的化学物质来安排化学反应。这差不多是我所有的了

实现不同的

比较器（请参阅）

比较器比较器1=新比较器（）{
公共int比较（MyEnum e1、MyEnum e2）{
//你的魔法就发生在这里
如果（…）
返回-1；
否则如果（…）
返回1；
返回0；
}
};
//和其他人，以不同的方式进行比较
//然后使用其中一个：
MyEnum[]allChemicals=MyEnum.values（）；
数组。排序（所有化学品，比较器1）//这是根据comparator1中的排序临界值对它们进行排序的方式。

假设您有一个元素枚举：

enum Elements {Oxygen, Hydrogen, Gold}

如果您想按照给定的顺序对它们进行排序，那么我可以：

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

其中

element比较器可以是：

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

公共类ElementComparator实现java.util.Comparator{
公共整数比较（元素左、元素右）{
返回right.compareTo（left）；//在此处使用您的条件
}
}

您的问题中不清楚订购标准的性质。它似乎是关于一些与化学反应有关的东西。我想标准应该放在
比较器中
来决定哪一个枚举元素比给定化学反应的另一个元素大。
你的意思是表示化学物质的实际对象是枚举？如果我可以说的话，这听起来像是一个奇怪的实现：枚举实际上更适合某些东西的“属性”

但无论如何。。。如果您确实希望将它们表示为枚举，然后对它们进行排序，我建议使用一个比较器，可以对特定类型的枚举进行排序，然后在其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...
        }
    }
};

比较器comp=新比较器（）{
公共整数比较（化学o1、化学o2）{
if（o1.反应性（）>o2.反应性（））{
返回1；
}否则如果（o1.反应性（）

然后，您可以将这个比较器传递给所涉及的排序方法、有序集合构造函数等

---

您可以扩展enum子类，以包括所需的任何额外方法，例如reactivity（）。

下面的示例显示了根据不同条件排序的相同enum值：

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

导入java.util.array；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.List；
公共类SortEnum{
公共枚举测试数{
A（1,2），B（5,1），C（3,0）；
私人投资价值1；
私人投资价值2；
私有测试数（int值1、int值2）{
此值为1.value1=value1；
此参数为0.value2=value2；
}
public int getValue1（）{
返回值1；
}
public int getValue2（）{
返回值2；
}
}
公共静态void main（字符串[]args）{
List=Arrays.asList（TestEnum.values（））；
系统错误打印项次（列表）；
Collections.sort（list，newcomparator（）{
@凌驾
公共整数比较（TestEnum o1，TestEnum o2）{
返回o1.getValue1（）-o2.getValue1（）；
}
});
系统错误打印项次（列表）；
Collections.sort（list，newcomparator（）{
@凌驾
公共整数比较（TestEnum o1，TestEnum o2）{
返回o1.getValue2（）-o2.getValue2（）；
}
});
系统错误打印项次（列表）；
}
}

输出为

[甲、乙、丙] [甲,丙,乙] [C、B、A]

---

您可以在枚举中放入任意数量的比较器，请参见以下示例：

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.Comparator；
公众普查日{
星期一（1，3），
星期二（2、6），
星期三（3、5），
星期四（4,4），
星期五（5月2日），
星期六（6月1日），
星期日（0,0）；
私人最终职位；
私有最终int工作层；
日（整数位置，整数级别）{
日历位置=位置；
工作级别=级别；
}
int getCalendarPosition（）{return calendarPosition；}
int getWorkLevel（）{return workLevel；}
公共静态比较器calendarPositionComparator=新比较器（）{
公共整数比较（d1天，d2天）{
返回d1.getCalendarPosition（）-d2.getCalendarPosition（）；
}
};
公共静态比较器workLevelComparator=新比较器（）{
公共整数比较（d1天，d2天）{
//降序，先硬一点
返回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());
    }
  }
}

导入java.util.array；
导入java.util.Collections；
导入java.util.List；
公共类枚举测试
{
公共静态void main（字符串[]args）{
List allDays=Arrays.asList（Day.values（））；
System.out.println（“==\n按日历位置的顺序列出天数：”；
Collections.sort（allDays、Day.calendarPositionComparator）；
展示项目（全天）；
System.out.println（“==\n按工作级别的顺序列出的天数：”；
Collections.sort（allDays、Day.workLevelComparator）；
展示项目（全天）；
}
公共静态无效显示项（列表天数）{
用于（天：天）{
System.out.println（day.name（））；
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());
    }
  }
}