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

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    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（）.concludes将是最好的方法。如果您有很多搜索，那么对数组进行排序可能是值得的，这样您就可以使用二进制搜索。这取决于您的应用程序。

我认为这是大多数人所期望的结果。以下是测试代码：

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));
    }
}

对于有限长度的阵列，请使用以下内容（由camickr提供）。这对于重复检查来说是缓慢的，特别是对于较长的阵列（线性搜索）。Arrays.asList（…）.incontains（…）如果您重复检查一组较大的元素，则可获得快速性能数组结构错误。使用TreeSet并将每个元素添加到其中。它对元素进行排序，并具有快速的exist（）方法（二进制搜索）。如果元素实现Comparable，则需要对TreeSet进行相应排序：ElementClass.compareTo（）方法必须与ElementClass.equals（）兼容：是否看到三合会未出现战斗？（Java Set缺少项目）TreeSet myElements=新TreeSet（）；//对每个元素执行此操作（实现*可比*）myElements.add（nextElement）；//*或者*，如果从其他代码强制提供数组：myElements.addAll（Arrays.asList（myArray））；否则，请使用您自己的比较器：类MyComparator实现Comparator＜ElementClass＞{int compareTo（ElementClass元素1；ElementClass元素2）{//元素的比较//应与对象相等性一致}布尔等于（对象otherComparator）{//您的比较器相等}}//用比较器构造TreeSetTreeSet myElements=新TreeSet（新MyComparator（））；//对每个元素执行此操作（实现*可比*）myElements.add（nextElement）；回报：检查某些元素的存在：//通过排序元素进行快速二进制搜索（性能~日志（大小））：boolean containsElement=myElements.exists（someElement）；

试试看：

ArrayList<Integer> arrlist = new ArrayList<Integer>(8);

// use add() method to add elements in the list
arrlist.add(20);
arrlist.add(25);
arrlist.add(10);
arrlist.add(15);

boolean retval = arrlist.contains(10);
if (retval == true) {
    System.out.println("10 is contained in the list");
}
else {
    System.out.println("10 is not contained in the list");
}

您可以使用Apache Commons Lang中的ArrayUtils.contains

公共静态布尔包含（Object[]数组，Object objectToFind）

注意，如果传递的数组为空，则此方法返回false。

还有一些方法可用于所有类型的基元数组。

例子：

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

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

使用Java 8，您可以创建一个流，并检查流中的任何条目是否与“s”匹配：

String[] values = {"AB","BC","CD","AE"};
boolean sInArray = Arrays.stream(values).anyMatch("s"::equals);

或作为通用方法：

public static <T> boolean arrayContains(T[] array, T value) {
    return Arrays.stream(array).anyMatch(value::equals);
}