Java 按值递减的顺序迭代枚举的所有值。

我有印度货币的清单

public enum HardCurrency {
    ONE(1), FIVE(5), TEN(10), TWENTY(20), FIFTY(50), HUNDRED(100), FIVE_HUNDRED(
            500), TWO_THOUSAND(2000);

    final static Logger logger = LoggerFactory.getLogger(HardCurrency.class);

    private final BigDecimal value;

    HardCurrency(int value) {
        this.value = new BigDecimal(value);
    }

    public BigDecimal getValue() {
        return value;
    }

}

如果我迭代这个枚举的所有值，代码就是这样的

for (HardCurrency curr : HardCurrency.values()) {
    logger.debug("{}", curr.getValue());
}

这将给出以下输出

[main] DEBUG c.p.v.ListAllValuesOfEnum - 1
[main] DEBUG c.p.v.ListAllValuesOfEnum - 5
[main] DEBUG c.p.v.ListAllValuesOfEnum - 10
[main] DEBUG c.p.v.ListAllValuesOfEnum - 20
[main] DEBUG c.p.v.ListAllValuesOfEnum - 50
[main] DEBUG c.p.v.ListAllValuesOfEnum - 100
[main] DEBUG c.p.v.ListAllValuesOfEnum - 500
[main] DEBUG c.p.v.ListAllValuesOfEnum - 2000

我需要以另一种方式得到它，并让它们以递减的值进行迭代

---

以保证的顺序列出枚举的所有值的最佳方式是什么

我认为最好的方法是创建

Comparator

实现并使用它对值进行排序。 您可以按如下方式定义反向比较器：

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

public class MyClass {
    public static void main(String args[]) {
        List<HardCurrency> hardCurrencies = Arrays.asList(HardCurrency.values());
        Collections.sort(hardCurrencies, new HardCurrencyInverseComparator());
        for (HardCurrency hc : hardCurrencies) {
            System.out.println(hc.getValue());
        }
    }

    enum HardCurrency {
        ONE(1), FIVE(5), TEN(10), TWENTY(20), FIFTY(50), HUNDRED(100), FIVE_HUNDRED(
                500), TWO_THOUSAND(2000);

        private final BigDecimal value;

        HardCurrency(int value) {
            this.value = new BigDecimal(value);
        }

        public BigDecimal getValue() {
            return value;
        }

    }

    static class HardCurrencyInverseComparator implements Comparator<HardCurrency> {

        public int compare(HardCurrency currency1, HardCurrency currency2) {
            return currency2.getValue().compareTo(currency1.getValue());
        }

    }




}

import java.math.BigDecimal；
导入java.util.Comparator；
导入java.util.array；
导入java.util.Collections；
导入java.util.List；
公共类MyClass{
公共静态void main（字符串参数[]）{
List HardCurrency=Arrays.asList（HardCurrency.values（））；
Collections.sort（硬通货，新的硬通货InverseComparator（））；
对于（硬通货hc：硬通货）{
System.out.println（hc.getValue（））；
}
}
枚举硬通货{
一（1）、五（5）、十（10）、二十（20）、五十（50）、一百（100）、五百(
500），两千（2000）；
私有最终大十进制值；
硬通货（整数值）{
this.value=新的BigDecimal（值）；
}
公共BigDecimal getValue（）{
返回值；
}
}
静态类HardCurrencyInverseComparator实现比较器{
公共整数比较（硬货币1、硬货币2）{
返回currency2.getValue（）.compareTo（currency1.getValue（））；
}
}
}

我已经测试了以下代码并正常工作：

    Comparator comparator1 = new Comparator<HardCurrency>() {

        public int compare(HardCurrency e1, HardCurrency e2) {

            if (e1.getValue().intValue() > e2.getValue().intValue()) {
                return -1;
            } else if (e1.getValue().intValue() < e2.getValue().intValue()) {
                return 1;
            }

            return 0;
        }
    };
    HardCurrency[] allCurrency = HardCurrency.values();
    Arrays.sort(allCurrency,comparator1);

    for (HardCurrency curr : allCurrency) {
        System.out.println(curr.getValue());
    }

比较器比较器1=新比较器（）{ 公共整数比较（硬货币e1、硬货币e2）{ 如果（e1.getValue（）.intValue（）>e2.getValue（）.intValue（））{ 返回-1； }else if（e1.getValue（）.intValue（）数组的顺序取决于源代码中定义的顺序。但是您不应该依赖它，因为它可能在未来发生变化，或者因为预期不同顺序的冲突用例

保证降序的最干净的解决方案是显式地按值排序。为了进行排序，您需要提供一个

比较器

。定义这种比较器的Java 8方法是一种单行程序：

Comparator.comparing(HardCurrency::getValue).reversed()

---

阐明你的另一种意思，不要依赖于声明顺序，即使你想按升序迭代它们。编写一个

比较器

，它按感兴趣的属性（即值）排序。您可以只比较BigDecimal实例：e1.getValue（）.compareTo（e2.getVaue（））是的，我知道，但我使用了那个：）