开发人员通常会：

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

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

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

or

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

return false;

第一个比第二个更可读。

如果数组未排序，则必须遍历所有内容，并对每个内容调用equals。

如果数组已排序，则可以执行二进制搜索，Arrays类中有一个。

一般来说，如果要进行大量的成员身份检查，您可能希望将所有内容存储在集合中，而不是存储在数组中。

对于有限长度的阵列，请使用以下内容（由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）；

只需手动执行即可：

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条件在方法中是常量。在方法调用期间，它始终计算为相同的布尔值。因此，如果输入数组很大，只计算一次这个条件会更有效，我们可以根据结果在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;
}

值得一提的是，我进行了一次测试，比较了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));
    }
}

如果你不想区分大小写

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