如何在针对enum Java中的每个项检查输入后打破循环？

我试图制作一个程序，允许用户输入元素周期表中某个元素的名称或符号，然后输出该元素的一些数据。到目前为止，我已经设法让用户能够输入名称或符号并正确输出，但是如果用户输入了错误的内容，那么代码不会输出任何内容，并且将停止接受符号输入，而只接受名称输入。我想知道如何才能打破循环，告诉用户，只有在针对枚举中的每个项检查了输入之后，他们的输入才是无效的，因为我当前的解决方案不起作用。我是Java新手，请简单解释一下如何使用Java以及为什么使用Java

import java.util.Scanner;
public class PeriodicTable {

    public enum Element {
        Hydrogen("H", "Nonmetal", "1.008"),
        Helium("He", "Noble Gas", "4.003"),
        Lithium("Li", "Alkali Metal", "6.941"),
        Beryllium("Be", "Alkaline Earth", "9.012"),
        Boron("B", "Semimetal", "10.811"),
        Carbon("C", "Nonmetal", "12.011"),
        //The rest of the periodic table is here, I just removed it for the sake of this post.

        private String symbol;
        private String group;
        private String weight;

        private Element(String symbol, String group, String weight) {
            this.symbol = symbol;
            this.group = group;
            this.weight = weight;
        }
    }

    static Element cName = null;
    public static void main(String[] args) {

        int counter = 0;
        System.out.println("Enter the name or symbol of an element in the periodic table. ");
        outer:
        do {
            Scanner reader = new Scanner(System.in);
            String input = reader.nextLine().trim();
            for (Element sy : Element.values()) {
                if (sy.symbol.equalsIgnoreCase(input)) {
                    System.out.println("Element: " + sy + " (" + sy.symbol + ")" + "\nGroup: " + sy.group + "\nAtomic Mass: " + sy.weight);
                    reader.close();
                    break outer;
                } else {
                    try {
                        cName = Element.valueOf(input.substring(0, 1).toUpperCase() + input.substring(1).toLowerCase());
                        System.out.println("Element: " + cName + " (" + cName.symbol + ")" + "\nGroup: " + cName.group + "\nAtomic Mass: " + cName.weight);
                        reader.close();
                        break outer;
                    } catch(IllegalArgumentException e) {
                        if(counter > Element.values().length) {
                            System.out.println("That name or symbol is not valid. Please try again. ");
                            continue outer;
                        } else {
                            counter++;
                            continue;
                        }
                    }
                }
            }
        } while (true);
    }
}

---

假设我理解您的问题，我会将解析

元素

（s）的逻辑添加到

元素

。您可以创建

映射

（s），一个映射到符号，另一个映射到对应的

元素

实例，然后按照您选择的顺序调用它们。像

private static Map<String, Element> symbolMap = new HashMap<>();
private static Map<String, Element> nameMap = new HashMap<>();
static {
    for (Element e : Element.values()) {
        symbolMap.put(e.symbol.toUpperCase(), e);
        nameMap.put(e.name().toUpperCase(), e);
    }
}

public static Element fromString(String token) {
    if (symbolMap.containsKey(token.toUpperCase())) {
        return symbolMap.get(token.toUpperCase());
    }
    return nameMap.get(token.toUpperCase());
}

---

如果

e

为

null

，则它不是有效的符号（或名称）。

假设我理解您的问题，我会将解析

元素的逻辑添加到
元素
。您可以创建
映射
（s），一个映射到符号，另一个映射到对应的
元素
实例，然后按照您选择的顺序调用它们。像

private static Map<String, Element> symbolMap = new HashMap<>();
private static Map<String, Element> nameMap = new HashMap<>();
static {
    for (Element e : Element.values()) {
        symbolMap.put(e.symbol.toUpperCase(), e);
        nameMap.put(e.name().toUpperCase(), e);
    }
}

public static Element fromString(String token) {
    if (symbolMap.containsKey(token.toUpperCase())) {
        return symbolMap.get(token.toUpperCase());
    }
    return nameMap.get(token.toUpperCase());
}

如果
e
为
null
，则它不是有效的符号（或名称）。
如果我理解正确，您需要检查枚举，看看是否有任何符号与用户输入匹配。如果没有，请打印一条消息并重试。您的方法是正确的，但是在catch块中，您不需要制作计数器。相反，如果我们仔细考虑设计，你就有了
breakouter如果输入匹配。因此，只有在没有匹配元素的情况下，才会到达do while循环的末尾。因此，如果我们在最后打印一条消息，这将实现我们的目标：

outer:
do {
    Scanner reader = new Scanner(System.in);
    String input = reader.nextLine().trim();
    for (Element sy : Element.values()) {
        if (sy.symbol.equalsIgnoreCase(input)) {
            System.out.println("Element: " + sy + " (" + sy.symbol + ")" + "\nGroup: " + sy.group + "\nAtomic Mass: " + sy.weight);
            reader.close();
            break outer;
        } else {
            try {
                cName = Element.valueOf(input.substring(0, 1).toUpperCase() + input.substring(1).toLowerCase());
                System.out.println("Element: " + cName + " (" + cName.symbol + ")" + "\nGroup: " + cName.group + "\nAtomic Mass: " + cName.weight);
                reader.close();
                break outer;
            } catch(IllegalArgumentException e) {
                continue;
            }
        }
    }
    System.out.println("Error. No matching elements. Please try again.");
} while (true);

样本输出：

如果我理解正确，您需要遍历枚举，看看是否有任何符号与用户输入匹配。如果没有，请打印一条消息并重试。您的方法是正确的，但是在catch块中，您不需要制作计数器。相反，如果我们仔细考虑设计，你就有了
breakouter如果输入匹配。因此，只有在没有匹配元素的情况下，才会到达do while循环的末尾。因此，如果我们在最后打印一条消息，这将实现我们的目标：

outer:
do {
    Scanner reader = new Scanner(System.in);
    String input = reader.nextLine().trim();
    for (Element sy : Element.values()) {
        if (sy.symbol.equalsIgnoreCase(input)) {
            System.out.println("Element: " + sy + " (" + sy.symbol + ")" + "\nGroup: " + sy.group + "\nAtomic Mass: " + sy.weight);
            reader.close();
            break outer;
        } else {
            try {
                cName = Element.valueOf(input.substring(0, 1).toUpperCase() + input.substring(1).toLowerCase());
                System.out.println("Element: " + cName + " (" + cName.symbol + ")" + "\nGroup: " + cName.group + "\nAtomic Mass: " + cName.weight);
                reader.close();
                break outer;
            } catch(IllegalArgumentException e) {
                continue;
            }
        }
    }
    System.out.println("Error. No matching elements. Please try again.");
} while (true);

样本输出：

我会避免在循环中使用
valueOf
方法。相反，您可以迭代元素，并为每个元素检查其名称（使用
name
方法）及其符号

Scanner reader = new Scanner(System.in);
outer: while (true) {
    System.out.println("Enter the name or symbol of an element in the periodic table. ");
    String input = reader.nextLine().trim();
    for (Element sy : Element.values()) {
        if (sy.symbol.equalsIgnoreCase(input) || sy.name().equalsIgnoreCase(input)) {
            System.out.println("Element: " + sy + " (" + sy.symbol + ")" + "\nGroup: " + sy.group + "\nAtomic Mass: " + sy.weight);
            break outer;
        }
    }
    System.out.println("No such element found. ");
}
reader.close(); // this might be a bad idea

我还将避免关闭
读取器
，因为这也将关闭
系统。在
中，您将无法读取更多输入。
我将避免在循环中使用
valueOf
方法。相反，您可以迭代元素，并为每个元素检查其名称（使用
name
方法）及其符号

Scanner reader = new Scanner(System.in);
outer: while (true) {
    System.out.println("Enter the name or symbol of an element in the periodic table. ");
    String input = reader.nextLine().trim();
    for (Element sy : Element.values()) {
        if (sy.symbol.equalsIgnoreCase(input) || sy.name().equalsIgnoreCase(input)) {
            System.out.println("Element: " + sy + " (" + sy.symbol + ")" + "\nGroup: " + sy.group + "\nAtomic Mass: " + sy.weight);
            break outer;
        }
    }
    System.out.println("No such element found. ");
}
reader.close(); // this might be a bad idea

我也会避免关闭
阅读器
，因为这也会关闭
系统。在
中，您将无法读取更多的输入。
您将混合搜索名称和搜索符号，从而使代码复杂化
对名称的搜索不需要在
for
循环中：

public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);
    System.out.println("Enter the name or symbol of an element in the periodic table. ");
    boolean found = false;
    do {
        String input = reader.nextLine().trim();

        try {
            cName = Element.valueOf(input.substring(0, 1).toUpperCase() + input.substring(1).toLowerCase());
            System.out.println("Element: " + cName + " (" + cName.symbol + ")" + "\nGroup: " + cName.group + "\nAtomic Mass: " + cName.weight);
            found = true;
        } catch (IllegalArgumentException e) {
        }

        for (Element sy : Element.values()) {
            if (sy.symbol.equalsIgnoreCase(input)) {
                found = true;
                System.out.println("Element: " + sy + " (" + sy.symbol + ")" + "\nGroup: " + sy.group + "\nAtomic Mass: " + sy.weight);
            }
        }

        if (!found)
            System.out.println("That name or symbol is not valid. Please try again. ");
    } while (!found);
    reader.close();
}

通过混合搜索名称和搜索符号，可以使代码复杂化
对名称的搜索不需要在
for
循环中：

public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);
    System.out.println("Enter the name or symbol of an element in the periodic table. ");
    boolean found = false;
    do {
        String input = reader.nextLine().trim();

        try {
            cName = Element.valueOf(input.substring(0, 1).toUpperCase() + input.substring(1).toLowerCase());
            System.out.println("Element: " + cName + " (" + cName.symbol + ")" + "\nGroup: " + cName.group + "\nAtomic Mass: " + cName.weight);
            found = true;
        } catch (IllegalArgumentException e) {
        }

        for (Element sy : Element.values()) {
            if (sy.symbol.equalsIgnoreCase(input)) {
                found = true;
                System.out.println("Element: " + sy + " (" + sy.symbol + ")" + "\nGroup: " + sy.group + "\nAtomic Mass: " + sy.weight);
            }
        }

        if (!found)
            System.out.println("That name or symbol is not valid. Please try again. ");
    } while (!found);
    reader.close();
}

您是否调试并逐步完成了代码？拥有这样大的方法是很难遵循的——试着将其分为
stringgetnextinput（Scanner reader）
和
elementgetelement（stringinput）
等方法。这将有助于简化流程和解决问题。您是否调试并逐步完成了代码？拥有这样大的方法是很难遵循的——试着将其分为
stringgetnextinput（Scanner reader）
和
elementgetelement（stringinput）
等方法。这将有助于简化流程和解决问题。