如果你不想区分大小写

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);

开发人员通常会：

Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);

上面的代码可以工作，但是不需要先将列表转换为set。将列表转换为集合需要额外的时间。它可以简单到：

Arrays.asList(arr).contains(targetValue);

或

for(String s: arr){
        if(s.equals(targetValue))
            return true;
    }

return false;

第一个比第二个可读。

使用简单的循环是最有效的方法。

boolean useLoop(String[] arr, String targetValue) {
    for(String s: arr){
        if(s.equals(targetValue))
            return true;
    }
    return false;
}

对programcreek的礼遇

arrays.aslist（）->然后调用contains（）方法将始终有效，但是搜索算法要好得多，因为不需要在数组周围创建轻量级的列表 Package 器，而arrays.aslist（）就是这样做的。

public boolean findString(String[] strings, String desired){
   for (String str : strings){
       if (desired.equals(str)) {
           return true;
       }
   }
   return false; //if we get here… there is no desired String, return false.
}

值得一提的是，我做了一个测试，比较了3个关于速度的建议。我生成了随机整数，将它们转换成字符串并将它们添加到数组中。然后，我搜索了可能的最高数字/字符串，这对于 asList().contains() .
当使用10k数组大小时，结果是：

Sort & Search   : 15
Binary Search   : 0
asList.contains : 0

使用100k阵列时，结果是：

Sort & Search   : 156
Binary Search   : 0
asList.contains : 32

因此，如果按排序顺序创建数组，则二进制搜索速度最快，否则 asList().contains 会是最好的选择。如果您有许多搜索，那么对数组进行排序可能是值得的，这样您就可以使用二进制搜索。这完全取决于你的申请。
我认为这是大多数人所期待的结果。测试代码如下：

import java.util.*;

public class Test
{
    public static void main(String args[])
    {
        long start = 0;
        int size = 100000;
        String[] strings = new String[size];
        Random random = new Random();

        for (int i = 0; i < size; i++)
            strings[i] = "" + random.nextInt( size );

        start = System.currentTimeMillis();
        Arrays.sort(strings);
        System.out.println(Arrays.binarySearch(strings, "" + (size - 1) ));
        System.out.println("Sort & Search : " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        System.out.println(Arrays.binarySearch(strings, "" + (size - 1) ));
        System.out.println("Search        : " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        System.out.println(Arrays.asList(strings).contains( "" + (size - 1) ));
        System.out.println("Contains      : " + (System.currentTimeMillis() - start));
    }
}

实际上，如果像tom hawtin建议的那样使用hashset，就不必担心排序问题，而且您的速度与预排序数组上的二进制搜索相同，甚至可能更快。
显然，这完全取决于代码的设置方式，但从我的立场来看，顺序是：
在未排序的数组上：
容器
aslist公司
排序二进制（&B）
在排序数组上：
容器
二元的
aslist公司
所以不管怎样，我都会赢的。

你可以用两种方法来检查
a） 通过将数组转换为字符串，然后通过.contains方法检查所需的字符串

String a=Arrays.toString(VALUES);
    System.out.println(a.contains("AB"));
    System.out.println(a.contains("BC"));
    System.out.println(a.contains("CD"));
    System.out.println(a.contains("AE"));

b） 这是一种更有效的方法

Scanner s=new Scanner(System.in);

   String u=s.next();
   boolean d=true;
    for(int i=0;i<VAL.length;i++)
    {
        if(VAL[i].equals(u)==d)
            System.out.println(VAL[i] +" "+u+VAL[i].equals(u));  

    }

可以使用arrays类对值执行二进制搜索。如果数组没有排序，则必须使用同一类中的排序函数对数组进行排序，然后在其中进行搜索。

检查数组是否包含值的四种不同方法
使用 List :

public static boolean useList(String[] arr, String targetValue) {
    return Arrays.asList(arr).contains(targetValue);
}

使用 Set :

public static boolean useSet(String[] arr, String targetValue) {
    Set<String> set = new HashSet<String>(Arrays.asList(arr));
    return set.contains(targetValue);
}

使用简单循环：

public static boolean useLoop(String[] arr, String targetValue) {
    for (String s: arr) {
        if (s.equals(targetValue))
            return true;
    }
    return false;
}

使用 Arrays.binarySearch() :
下面的代码是错误的，为了完整起见，这里列出了它。 binarySearch() 只能用于排序数组。你会发现下面的结果很奇怪。这是排序数组时的最佳选项。

public static boolean binarySearch(String[] arr, String targetValue) {  
    return Arrays.binarySearch(arr, targetValue) >= 0;
}

快速示例：

String testValue="test";
String newValueNotInList="newValue";
String[] valueArray = { "this", "is", "java" , "test" };
Arrays.asList(valueArray).contains(testValue); // returns true
Arrays.asList(valueArray).contains(newValueNotInList); // returns false

你可以用 ArrayUtils.contains 来自apache commons lang public static boolean contains(Object[] array, Object objectToFind) 请注意，此方法返回 false 如果传递的数组是 null .
还有一些方法可用于各种基本数组。

示例：

String[] fieldsToInclude = { "id", "name", "location" };

if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) {
    // Do some stuff.
}

只需手动执行即可：

public static <T> boolean contains(final T[] array, final T v) {
    for (final T e : array)
        if (e == v || v != null && v.equals(e))
            return true;

    return false;
}

改进：
这个 v != null 方法内部的条件是恒定的。在方法调用期间，它总是计算为相同的布尔值。所以如果输入 array 是大的，只计算一次这个条件更有效，我们可以在内部使用一个简化的/更快的条件 for 基于结果的循环。改进的 contains() 方法：

public static <T> boolean contains2(final T[] array, final T v) {
    if (v == null) {
        for (final T e : array)
            if (e == null)
                return true;
    } 
    else {
        for (final T e : array)
            if (e == v || v.equals(e))
                return true;
    }

    return false;
}

尝试使用Java8 predicate 测试方法
下面是一个完整的例子。

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Test {
 public static final List<String> VALUES = Arrays.asList("AA", "AB", "BC", "CD", "AE");

 public static void main(String args[]) {
  Predicate<String> containsLetterA = VALUES -> VALUES.contains("AB");
  for (String i : VALUES) {

   System.out.println(containsLetterA.test(i));
  } 
 }
}

http://mytechnologythought.blogspot.com/2019/10/java-8-predicate-test-method-example.html
https://github.com/vipulgulhane1/java8/blob/master/test.java

创建一个最初设置为false的布尔值。运行一个循环来检查数组中的每个值，并与要检查的值进行比较。如果得到匹配，请将boolean设置为true并停止循环。然后Assert布尔值为真。

obstupidanswer（但我认为在这里有一个教训）：

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}