Java 检查字符串x是否等于字符串[]中的任何字符串

如果用户输入的字符串等于字符串数组中的任何字符串，我将尝试将布尔值设置为true

我即兴创作并想出了这个

String[] cancelWords = {"cancel", "nevermind", "scratch that"};
boolean valueEqualsCancel = true;
for(String cancelWord : cancelWords) {
  if(!valueEqualsCancel) break;
  valueEqualsCancel =  valueEqualsCancel && value.equals(cancelWord);
}

但是

valueequalscale

从来都不是真的

---

任何提示？

将

数组

转换为

列表

，然后使用

包含

方法进行检查

---

Arrays.asList（cancelWords）.contains（value）

valueequalscale永远不会为真，因为当您找到cancelWord时，您不会退出循环

为了达到break语句，需要将valueEqualsCancel设置为false

例如，如果在第一个循环后搜索“cancel”，则变量值equalCancel为：

valueEqualsCancel =  valueEqualsCancel && value.equals(cancelWord) = TRUE && TRUE = TRUE;

所以在第二个循环中，你不会打破。然后再次计算表达式

valueEqualsCancel =  valueEqualsCancel && value.equals(cancelWord) = TRUE && FALSE = FALSE;      

因此，在第三个循环中，您将退出，valueEqualsCancel为false

您可以通过以下方式更正代码：

String[] cancelWords = {"cancel", "nevermind", "scratch that"};
boolean found = false;
for(String cancelWord : cancelWords) {
  found = value.equals(cancelWord);
  if (found) break;
}

---

您的初始值已关闭，可以改善流量：

String[] cancelWords = {"cancel", "nevermind", "scratch that"};
boolean valueEqualsCancel = false; // fix
for(String cancelWord : cancelWords) {
  if(value.equals(cancelWord)) {
    valueEqualsCancel =  true;
    break;
  }
}

---

您可以执行以下操作：

Arrays.asList(cancelWords).contains(value)

（见附件）

如果您要执行这样的多个查询，请将所有单词放入一个查询中，然后使用此方法进行查询。

使用以下方法：

public boolean containsWord(String word, String[] words) {
   for(String cancelWord : words) {
      if(word.equals(cancelWord)) {
        return true;
      }
   }
   return false;

}

---

我希望这有帮助。

我想这应该会有帮助：-

import java.util.Scanner;


public class check4 {
    public static void main(String args[])
    {
       Scanner scan = new Scanner(System.in);
       String value = scan.nextLine().toString();
       String[] cancelWords = {"cancel", "nevermind", "scratch that"};
       boolean valueEqualsCancel = false;
       for(int i=0;i<cancelWords.length;i++) {
          if(value.equals(cancelWords[i])) {
             valueEqualsCancel = true;
             break;
          }
       }
       System.out.println(valueEqualsCancel);
    }
}

输出：

true

试一试

 String[] cancelWords = {"cancel", "nevermind", "scratch that"};     
  boolean valueEqualsCancel = true;     
  for(String cancelWord : cancelWords) {      
  if(!valueEqualsCancel) break;     
   valueEqualsCancel =  !(valueEqualsCancel && value.equals(cancelWord));     
 }

使用这种方法

public static boolean  isContainsWords(String[] words,String Targent){

               boolean flag;
               for(String buf : words){
                     if(buf.equals(Targent))
                          return flag = true;
               }
               return flag = false;

}

---

这似乎很完美

最适合您的解决方案取决于取消单词的数量以及是否需要比较不区分大小写。我添加了两种可能的实现方法的代码：

// I would use a HashSet which needs constant time to compare, even with long lists of cancel words
// Note, that the use of toLowerCase() makes the comparison case insensitive.
@Test
public final void test2() {
    String value = "nevermind";
    HashSet<String> cancelWords = new HashSet<String>();
    cancelWords.addAll(Arrays.asList(new String[] {"cancel", "nevermind", "scratch that"}));

    boolean valueEqualsCancel = cancelWords.contains(value.toLowerCase());
    System.out.println("test2: " + valueEqualsCancel);
}

// You might like to know, which cancel word it was
@Test
public final void test3() {
    String value = "nevermind";
    String[] cancelWords = {"cancel", "nevermind", "scratch that"};
    Arrays.sort(cancelWords); // Prepare for binary search

    // The returned value indicates either which cancel word was used or, that nothing was found with result < 0.
    System.out.println("test3: nevermind " + Arrays.binarySearch(cancelWords, "nevermind"));
    System.out.println("test3: cancel " + Arrays.binarySearch(cancelWords, "cancel"));
    System.out.println("test3: something totally different " + Arrays.binarySearch(cancelWords, "something totally different"));
}

//我会使用一个HashSet，它需要恒定的时间进行比较，即使有很长的取消字列表也是如此
//注意，使用toLowerCase（）使比较不区分大小写。
@试验
公开最终作废测试2（）{
String value=“nevermind”；
HashSet cancelWords=新HashSet（）；
cancelWords.addAll（Arrays.asList（新字符串[]{“cancel”、“nevermind”、“scratch that}））；
布尔值equalCancel=cancelWords.contains（value.toLowerCase（））；
System.out.println（“test2:+valueEqualsCancel”）；
}
//你可能想知道，它是哪个词
@试验
公开最终无效测试3（）{
String value=“nevermind”；
字符串[]cancelWords={“取消”、“不终止”、“划伤该”}；
Arrays.sort（cancelWords）；//准备进行二进制搜索
//返回的值表示使用了哪个取消字，或者未找到任何结果小于0的内容。
System.out.println（“test3:nevermind”+Arrays.binarySearch（cancelWords，“nevermind”）；
System.out.println（“test3:cancel”+Arrays.binarySearch（cancelWords，“cancel”）；
System.out.println（“test3：完全不同的东西”+数组.binarySearch（cancelWords，“完全不同的东西”）；
}

以下是一个使用Java 8的2行程序，易于阅读：

String[] cancelWords = {"cancel", "nevermind", "scratch that"};
boolean valueEqualsCancel = Arrays.stream(cancelWords).anyMatch(value::equals);

如果您有，您可以使用：

---

contains不起作用，因为值必须与数组中的字符串完全相同。e、 g.值可能是“cancel that”，但这不等于数组中的“cancel”。使用问题中的

equals

方法。我认为OP也在尝试这样做。这是一个很好的答案，因为它鼓励OP使用已经存在的结构，而不是手工编码。我无法评论提供的确切解决方案是否是OP所需的。@MattSmith[

Collection.contains（）

]（当您找到“cancel”时，您的循环不会退出。它将设置为false，因为“nevermind”和“scratch that”不等于“cancel”。找到匹配项后，退出循环。不要在其余元素上循环。检查jdk8。OP没有说明正在排序的列表，也没有说明执行搜索的次数。因此，我不知道binarySearch注释是否合适。这看起来是最好的答案。编写for循环搜索数组，br找到结果时eak是我在Java中经常使用的一种模式。我看不出这个伪代码有什么问题。我不理解-1。不管输入如何，这不是总是输出

true

吗？@NullUserException：你是对的，我做了一个编辑，如果你从不使用它的值？+1，用于将单词放入一个集合。不过，我不同意

asList

方法，因为这会增加相当多的开销。对于小数组来说这很好，但对大数据集会有明显的影响。@Kevin感谢您的支持：）为什么说

asList

会增加开销？它创建了一个由您传入的任何数组直接支持的列表（不涉及复制），因此无论数组大小如何，相关成本都很低。我假设创建列表是O（n）。

// I would use a HashSet which needs constant time to compare, even with long lists of cancel words
// Note, that the use of toLowerCase() makes the comparison case insensitive.
@Test
public final void test2() {
    String value = "nevermind";
    HashSet<String> cancelWords = new HashSet<String>();
    cancelWords.addAll(Arrays.asList(new String[] {"cancel", "nevermind", "scratch that"}));

    boolean valueEqualsCancel = cancelWords.contains(value.toLowerCase());
    System.out.println("test2: " + valueEqualsCancel);
}

// You might like to know, which cancel word it was
@Test
public final void test3() {
    String value = "nevermind";
    String[] cancelWords = {"cancel", "nevermind", "scratch that"};
    Arrays.sort(cancelWords); // Prepare for binary search

    // The returned value indicates either which cancel word was used or, that nothing was found with result < 0.
    System.out.println("test3: nevermind " + Arrays.binarySearch(cancelWords, "nevermind"));
    System.out.println("test3: cancel " + Arrays.binarySearch(cancelWords, "cancel"));
    System.out.println("test3: something totally different " + Arrays.binarySearch(cancelWords, "something totally different"));
}

String[] cancelWords = {"cancel", "nevermind", "scratch that"};
boolean valueEqualsCancel = Arrays.stream(cancelWords).anyMatch(value::equals);

String[] cancelWords = {"cancel", "nevermind", "scratch that"};
boolean valueEqualsCancel = StringUtils.equalsAny(value, cancelWords);