Java 如何使用Arraylist忽略逗号并打印出元素<；字符串>；？

我想检查输入是否包含

“奶酪三明治”、“玉米三明治”

和

“混合蔬菜三明治”

。条件是：

如果输入的输入与

Arraylist

中存储的元素匹配，则打印出元素

如果输入与

Arraylist

中存储的元素不匹配，请打印

不正确的输入

如果输入可以包含由逗号分隔的长字符串，则必须忽略逗号并打印逗号之间的字符串

在我的程序中，我创建了一个列表并将这三个字符串存储在其中，然后循环它们并检查输入是否与存储的元素匹配。问题是当输入以字符串的形式给出，然后用逗号添加这些元素时，它不会给我任何信息或错误的输入。如何忽略逗号并拆分要打印的字符串，如下所示

示例：

String Input = "Cheese Sandwich, Corn Sandwich, Mix Veg Sandwich"; 

预期产出

奶酪三明治
玉米三明治
混合蔬菜三明治

我的节目

static void storeElements(String input) {

    List<String> sandwiches = new ArrayList<>();
    sandwiches.add("corn sandwich");
    sandwiches.add("mix veg sandwich");
    sandwiches.add("cheese sandwich");
    sandwiches.add("mix veg sandwich");
    sandwiches.add("cheese sandwich");
   

    boolean a = sandwiches.contains(input);
    boolean b = input.contains(",");

    List<String> list = new ArrayList(Arrays.asList(input.split(",")));

---

这是您的初始代码，带有一些注释

   static void storeElements(String input) {
            List<String> sandwiches = new ArrayList<>();
            sandwiches.add("corn sandwich");
            sandwiches.add("mix veg sandwich");
            sandwiches.add("cheese sandwich");
            sandwiches.add("mix veg sandwich");
            sandwiches.add("cheese sandwich");               
    
            boolean a = sandwiches.contains(input); // boolean a is set here, and it is never changed. So, if you enter "cheese sandwich, mix veg sandwich" a will never become true.
            boolean b = input.contains(",");
    
            List<String> list = new ArrayList(Arrays.asList(input.split(",")));
    
            for (int i = 0; i < input.length(); i++) {
                if (b) {
                        for (String c : sandwiches) { // You shouldn't be iterating over sandwiches, but over list
                            if (a) { // a is not dependent on your c. this test should only be done if b is false. here, you need to check if an element of list is in sandwiches
                                System.out.println(c);
                            }
                            else {
                                System.out.println("Incorrect Input");
                            }
                        }
                }
            }
        }

静态void存储元素（字符串输入）{
列表三明治=新的ArrayList（）；
三明治。添加（“玉米三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；
布尔值a=sandwiches.contains（input）；//布尔值a在这里设置，并且永远不会更改。因此，如果您输入“奶酪三明治，混合蔬菜三明治”，a将永远不会变为真。
布尔b=输入。包含（“，”）；
List List=newarraylist（Arrays.asList（input.split（“，”））；
对于（int i=0；i

修改后的代码

static void storeElements(String input) {
    List<String> sandwiches = new ArrayList<>();
    sandwiches.add("corn sandwich");
    sandwiches.add("mix veg sandwich");
    sandwiches.add("cheese sandwich");
    sandwiches.add("mix veg sandwich");
    sandwiches.add("cheese sandwich");

    boolean a = sandwiches.contains(input);
    boolean b = input.contains(",");

    List<String> list = new ArrayList(Arrays.asList(input.split(", ")));


        if (b) {
            for (String c : list) {
                System.out.println(sandwiches.contains(c) ? c : "Incorrect Input");
            }
        } else {
            System.out.println(a ? input : "Incorrect Input"); // here it makes sense to check if a is true
        }
}

静态void存储元素（字符串输入）{
列表三明治=新的ArrayList（）；
三明治。添加（“玉米三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；
布尔值a=三明治。包含（输入）；
布尔b=输入。包含（“，”）；
List List=newarraylist（Arrays.asList（input.split（“，”））；
如果（b）{
for（字符串c:列表）{
System.out.println（三明治包含（c）？c：“输入错误”）；
}
}否则{
System.out.println（a？输入：“输入不正确”）；//这里检查a是否为真是有意义的
}
}

可简化为：

static void storeElements(String input) {
    List<String> sandwiches = new ArrayList<>();
    sandwiches.add("corn sandwich");
    sandwiches.add("mix veg sandwich");
    sandwiches.add("cheese sandwich");
    sandwiches.add("mix veg sandwich");
    sandwiches.add("cheese sandwich");

    List<String> list = new ArrayList(Arrays.asList(input.split(", ")));
    for (String c : list) {
      System.out.println(sandwiches.contains(c) ? c : "Incorrect Input");
    }
}

静态void存储元素（字符串输入）{
列表三明治=新的ArrayList（）；
三明治。添加（“玉米三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；
List List=newarraylist（Arrays.asList（input.split（“，”））；
for（字符串c:列表）{
System.out.println（三明治包含（c）？c：“输入错误”）；
}
}

在我最初的回答中，我将（“，”）一分为二，这是我从原文中复制的，但我忽略了这一点：

如果对“奶酪三明治，玉米三明治”执行拆分（“，”），则会得到“奶酪三明治”和“玉米三明治”。第一个会被发现，第二个不会，因为“玉米”和“玉米”不一样，所以空间确实会有所不同

编辑：仅在不匹配时打印不正确的输入

static void storeElements(String input) {
    List<String> sandwiches = new ArrayList<>();
    sandwiches.add("corn sandwich");
    sandwiches.add("mix veg sandwich");
    sandwiches.add("cheese sandwich");
    sandwiches.add("mix veg sandwich");
    sandwiches.add("cheese sandwich"); // this line is not relevant, the value is already in sandwiches

    List<String> list = new ArrayList(Arrays.asList(input.split(", ")));
    List<String> result = new ArrayList<>();
    
    for (String c : list) {
      if ( sandwiches.contains(c)) {
          result.add(c); // only add the String if it is found in the original list
      } else {
              result.clear();
              break;
      }
    }

    if ( result.isEmpty()) {
        // this will only happen if no elements have been added to the result list
        System.out.println("Incorrect input");
    } else {
        for ( String found : result ) {
            System.out.println(found);
        }
    }
}

静态void存储元素（字符串输入）{
列表三明治=新的ArrayList（）；
三明治。添加（“玉米三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；//此行不相关，值已在三明治中
List List=newarraylist（Arrays.asList（input.split（“，”））；
列表结果=新建ArrayList（）；
for（字符串c:列表）{
if（三明治含（c））{
result.add（c）；//仅在原始列表中找到字符串时添加该字符串
}否则{
result.clear（）；
打破
}
}
if（result.isEmpty（））{
//只有在结果列表中未添加任何元素时才会发生这种情况
System.out.println（“输入错误”）；
}否则{
for（找到字符串：结果）{
System.out.println（已找到）；
}
}
}

认识到只有一种输入需要考虑，您可以大大简化事情：以逗号分隔的项目列表<代码>“奶酪三明治、玉米三明治、混合蔬菜三明治”显然是一个逗号分隔的列表，包含三个项目<代码>“奶酪三明治”，不太明显，也是一个逗号分隔的列表，只有一个项目

因此，只要将所有输入作为逗号分隔的列表进行处理，一切就变得不那么复杂了：

static void storeElements(String input) {

        List<String> sandwiches = new ArrayList<>();
        sandwiches.add("corn sandwich");
        sandwiches.add("mix veg sandwich");
        sandwiches.add("cheese sandwich");
        sandwiches.add("mix veg sandwich");
        sandwiches.add("cheese sandwich");
       
        List<String> list = new ArrayList(Arrays.asList(input.split("\\s*,\\s*")));

        for (String item : list) {
            item = item.toLowerCase();
            if (sandwiches.contains(item) {
                System.out.println("Yes, we have " + item);
            } else {
                System.out.println("Incorrect input");
            }
        }
}

静态void存储元素（字符串输入）{
列表三明治=新的ArrayList（）；
三明治。添加（“玉米三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；
三明治。添加（“混合蔬菜三明治”）；
三明治。添加（“奶酪三明治”）；
列表列表=新的ArrayList（Arrays.asList（input.split（“\\s*，\\s*”））；
用于（字符串项）
static void storeElements(String input) {

        List<String> sandwiches = new ArrayList<>();
        sandwiches.add("corn sandwich");
        sandwiches.add("mix veg sandwich");
        sandwiches.add("cheese sandwich");
        sandwiches.add("mix veg sandwich");
        sandwiches.add("cheese sandwich");
       
        List<String> list = new ArrayList(Arrays.asList(input.split("\\s*,\\s*")));

        for (String item : list) {
            item = item.toLowerCase();
            if (sandwiches.contains(item) {
                System.out.println("Yes, we have " + item);
            } else {
                System.out.println("Incorrect input");
            }
        }
}