Java 在枚举中查找最高值

我正在为我正在制作的游戏制作一个类，但我不知道如何向用户返回最高的“奖励”：

我想让它做的是根据玩家的杀戮回报奖励。如果他有38次杀戮，应该只会返回300次。也不是150

    class EnumTest {

private static int playerKills = 38;

private enum KillReward {

    BEGINNER(10, 150),
    JUNIOR(25, 300),
    EXPERT(50, 500),
    CHAMPION(100, 1000);

    private KillReward(int kills, int reward) {
        this.kills = kills;
        this.reward = reward;
    }

    private int kills, reward;

    private int getKillsNeeded() {
        return kills;
    }

    private int getKillReward() {
        return reward;
    }
}

public static void main (String[] args) {
    for (KillReward k : KillReward.values()) {
        if (playerKills > k.getKillsNeeded()) {
            System.out.println("Kills: " + playerKills + "; Reward: " + k.getKillReward());
        }
    }
}

---

}有几种方法可以做到这一点

一种简单的方法是将奖励分配给变量。在循环结束时，下面的

奖励

变量将是适用的最高杀戮奖励

public static void main (String[] args) {
    KillReward reward = null;
    for (KillReward k : KillReward.values()) {
        if (playerKills > k.getKillsNeeded()) {
            reward = k;
        }
    }
    System.out.println("Kills: " + playerKills + "; Reward: " + k.getKillReward());
}

请注意，这取决于枚举的顺序，而枚举的顺序有时可能很脆弱。例如，如果在CHAMPION之后添加了一个新的KillReward枚举，但其KillsNeed值较低，那么它将不会返回正确的值

更好的解决方案是创建一个比较器，并使用它首先按killsNeeded对枚举值进行排序，从而确保它们始终是有序的。如果您也按降序排序，那么您也可以在命中第一个适用循环后中断循环

class EnumTest {

    private enum KillReward {

        BEGINNER(10, 150), JUNIOR(25, 300), EXPERT(50, 500), CHAMPION(100, 1000);

        // Sort KillRewards once at initialization
        private static final List<KillReward> sortedKillRewards = new ArrayList<KillReward>();
        static {
            for (KillReward k : values())
                sortedKillRewards.add(k);
            Collections.sort(sortedKillRewards, new Comparator<KillReward>() {
                @Override
                public int compare(KillReward o1, KillReward o2) {
                    return (o1.kills - o2.kills) * -1; // multiplying by -1 makes it
                    // descending
                }
            });
        }

        private KillReward(int kills, int reward) {
            this.kills = kills;
            this.reward = reward;
        }

        private int kills, reward;

        private int getKillsNeeded() {
            return kills;
        }

        private int getKillReward() {
            return reward;
        }

        public static KillReward forKills(int killCount) {
            for (KillReward k : sortedKillRewards)
                if (killCount >= k.kills)
                    return k;

            // must not have enough kills for any reward
            return null;
        }
    }

    public static void main(String[] args) {
        int kills = 9;
        System.out.println("Kills: " + kills + "; Reward: "
                + KillReward.forKills(kills));

        kills = 10;
        System.out.println("Kills: " + kills + "; Reward: "
                + KillReward.forKills(kills));

        kills = 38;
        System.out.println("Kills: " + kills + "; Reward: "
                + KillReward.forKills(kills));
    }

}

类枚举测试{
私人枚举杀手奖励{
初学者（10150）、初级（25300）、专家（50500）、冠军（1001000）；
//在初始化时对数据进行一次排序
私有静态最终列表sortedKillRewards=new ArrayList（）；
静止的{
for（k:values（））
添加（k）；
Collections.sort（sortedKillRewards，新的Comparator（）{
@凌驾
公共整数比较（KillReward o1，KillReward o2）{
return（o1.kills-o2.kills）*-1；//乘以-1表示返回
//下降的
}
});
}
私人杀人奖励（整数杀人，整数奖励）{
this.kills=杀死；
这个。奖励=奖励；
}
私人int杀人，奖励；
private int getkillsneed（）{
还击；
}
private int getKillReward（）{
回报奖励；
}
公共静态kills（int killCount）{
对于（KillReward k:sortedKillRewards）
如果（killCount>=k.kills）
返回k；
//必须没有足够的杀戮来获得任何奖励
返回null；
}
}
公共静态void main（字符串[]args）{
int=9；
System.out.println（“杀死：+杀死+”奖励：
+杀戮奖励。福克斯（杀戮））；
死亡人数=10人；
System.out.println（“杀死：+杀死+”奖励：
+杀戮奖励。福克斯（杀戮））；
死亡人数=38人；
System.out.println（“杀死：+杀死+”奖励：
+杀戮奖励。福克斯（杀戮））；
}
}

有几种方法可以做到这一点

一种简单的方法是将奖励分配给变量。在循环结束时，下面的

奖励

变量将是适用的最高杀戮奖励

public static void main (String[] args) {
    KillReward reward = null;
    for (KillReward k : KillReward.values()) {
        if (playerKills > k.getKillsNeeded()) {
            reward = k;
        }
    }
    System.out.println("Kills: " + playerKills + "; Reward: " + k.getKillReward());
}

请注意，这取决于枚举的顺序，而枚举的顺序有时可能很脆弱。例如，如果在CHAMPION之后添加了一个新的KillReward枚举，但其KillsNeed值较低，那么它将不会返回正确的值

更好的解决方案是创建一个比较器，并使用它首先按killsNeeded对枚举值进行排序，从而确保它们始终是有序的。如果您也按降序排序，那么您也可以在命中第一个适用循环后中断循环

class EnumTest {

    private enum KillReward {

        BEGINNER(10, 150), JUNIOR(25, 300), EXPERT(50, 500), CHAMPION(100, 1000);

        // Sort KillRewards once at initialization
        private static final List<KillReward> sortedKillRewards = new ArrayList<KillReward>();
        static {
            for (KillReward k : values())
                sortedKillRewards.add(k);
            Collections.sort(sortedKillRewards, new Comparator<KillReward>() {
                @Override
                public int compare(KillReward o1, KillReward o2) {
                    return (o1.kills - o2.kills) * -1; // multiplying by -1 makes it
                    // descending
                }
            });
        }

        private KillReward(int kills, int reward) {
            this.kills = kills;
            this.reward = reward;
        }

        private int kills, reward;

        private int getKillsNeeded() {
            return kills;
        }

        private int getKillReward() {
            return reward;
        }

        public static KillReward forKills(int killCount) {
            for (KillReward k : sortedKillRewards)
                if (killCount >= k.kills)
                    return k;

            // must not have enough kills for any reward
            return null;
        }
    }

    public static void main(String[] args) {
        int kills = 9;
        System.out.println("Kills: " + kills + "; Reward: "
                + KillReward.forKills(kills));

        kills = 10;
        System.out.println("Kills: " + kills + "; Reward: "
                + KillReward.forKills(kills));

        kills = 38;
        System.out.println("Kills: " + kills + "; Reward: "
                + KillReward.forKills(kills));
    }

}

类枚举测试{
私人枚举杀手奖励{
初学者（10150）、初级（25300）、专家（50500）、冠军（1001000）；
//在初始化时对数据进行一次排序
私有静态最终列表sortedKillRewards=new ArrayList（）；
静止的{
for（k:values（））
添加（k）；
Collections.sort（sortedKillRewards，新的Comparator（）{
@凌驾
公共整数比较（KillReward o1，KillReward o2）{
return（o1.kills-o2.kills）*-1；//乘以-1表示返回
//下降的
}
});
}
私人杀人奖励（整数杀人，整数奖励）{
this.kills=杀死；
这个。奖励=奖励；
}
私人int杀人，奖励；
private int getkillsneed（）{
还击；
}
private int getKillReward（）{
回报奖励；
}
公共静态kills（int killCount）{
对于（KillReward k:sortedKillRewards）
如果（killCount>=k.kills）
返回k；
//必须没有足够的杀戮来获得任何奖励
返回null；
}
}
公共静态void main（字符串[]args）{
int=9；
System.out.println（“杀死：+杀死+”奖励：
+杀戮奖励。福克斯（杀戮））；
死亡人数=10人；
System.out.println（“杀死：+杀死+”奖励：
+杀戮奖励。福克斯（杀戮））；
死亡人数=38人；
System.out.println（“杀死：+杀死+”奖励：
+杀戮奖励。福克斯（杀戮））；
}
}

感谢您的回复！我从来没有用过比较仪。你介意给我一些关于使用比较器的见解吗？我在上面添加了一个使用比较器的版本。很漂亮。。。非常感谢。感谢您的回复！我从来没有用过比较仪。你介意给我一些关于使用比较器的见解吗？我在上面添加了一个使用比较器的版本。很漂亮。。。非常感谢。