在Java中，如何确定一个数组是否包含特定的值？

这是一个愚蠢的回答（但我认为其中有一些教训）：

enum Values {
    AB, BC, CD, AE
}

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

开发人员通常会做以下事情：

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

以上代码是可行的，但没有必要先将列表转换为集合。将列表转换为集合需要额外的时间。可以简单地这样写：

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

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

return false;

第一个比第二个更易读。

实际上，如果您使用Tom Hawtin提出的HashSet<String>，则无需担心排序问题，并且速度与对预排序数组进行二进制搜索相同，甚至可能更快。

显然，这完全取决于您的代码设置方式，但从我的角度来看，排序顺序应该是：

在一个未排序 的数组上：

1. HashSet
2. asList
3. sort & binary

在已排序的数组上：

1. HashSet
2. Binary
3. asList

因此，无论哪种方式，都应选择HashSet。

private static final Set<String> VALUES =  ImmutableSet.of("AB","BC","CD","AE");

在Java 8中使用流（Streams）。

List<String> myList =
        Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList.stream()
        .filter(s -> s.startsWith("c"))
        .map(String::toUpperCase)
        .sorted()
        .forEach(System.out::println);

一个可能的解决方案：

import java.util.Arrays;
import java.util.List;

public class ArrayContainsElement {
  public static final List<String> VALUES = Arrays.asList("AB", "BC", "CD", "AE");

  public static void main(String args[]) {

      if (VALUES.contains("AB")) {
          System.out.println("Contains");
      } else {
          System.out.println("Not contains");
      }
  }
}

最短的解决方案
数组 VALUES 可能包含重复项
自Java 9以来

List.of(VALUES).contains(s);

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

Courtesy to Programcreek

请使用以下代码（contains() 方法在此代码中为 ArrayUtils.in()）：

ObjectUtils.java

public class ObjectUtils {
    /**
     * A null safe method to detect if two objects are equal.
     * @param object1
     * @param object2
     * @return true if either both objects are null, or equal, else returns false.
     */
    public static boolean equals(Object object1, Object object2) {
        return object1 == null ? object2 == null : object1.equals(object2);
    }
}

ArrayUtils.java

public class ArrayUtils {
    /**
     * Find the index of of an object is in given array,
     * starting from given inclusive index.
     * @param ts    Array to be searched in.
     * @param t     Object to be searched.
     * @param start The index from where the search must start.
     * @return Index of the given object in the array if it is there, else -1.
     */
    public static <T> int indexOf(final T[] ts, final T t, int start) {
        for (int i = start; i < ts.length; ++i)
            if (ObjectUtils.equals(ts[i], t))
                return i;
        return -1;
    }

    /**
     * Find the index of of an object is in given array, starting from 0;
     * @param ts Array to be searched in.
     * @param t  Object to be searched.
     * @return indexOf(ts, t, 0)
     */
    public static <T> int indexOf(final T[] ts, final T t) {
        return indexOf(ts, t, 0);
    }

    /**
     * Detect if the given object is in the given array.
     * @param ts Array to be searched in.
     * @param t  Object to be searched.
     * @return If indexOf(ts, t) is greater than -1.
     */
    public static <T> boolean in(final T[] ts, final T t) {
        return indexOf(ts, t) > -1;
    }
}

从上面的代码中可以看出，还有其他实用方法ObjectUtils.equals()和ArrayUtils.indexOf()也在其他地方使用过。

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