您可以使用下面的java 8代码将原始int数组转换为整数数组列表，

List<Integer> arrayElementsList = Arrays.stream(yourArray).boxed().collect(Collectors.toList());

然后使用 contains() 方法来检查列表是否包含特定元素，

boolean containsElement = arrayElementsList.contains(key);

解决方案#1
由于最初的问题只需要一个简化的解决方案（而不是更快的解决方案），这里有一个单行解决方案：

public boolean contains(int[] array, int key) {
    return Arrays.toString(array).matches(".*[\\[ ]" + key + "[\\],].*");
}

说明：javadoc of Arrays.toString() 状态结果用方括号括起来，相邻元素用字符“，”（逗号后跟空格）分隔。所以我们可以指望这个。首先我们皈依 array 然后我们检查 key 包含在此字符串中。当然，我们不能接受“子编号”（例如，“1234”包含“23”），因此我们必须寻找 key 前有一个左括号或空格，后有一个右括号或逗号。
注意：所使用的regexp模式还可以正确地处理负数（其字符串表示形式以减号开头）。
解决方案#2
此解决方案已发布，但包含错误，因此我发布正确的解决方案：

public boolean contains(int[] array, int key) {
    Arrays.sort(array);
    return Arrays.binarySearch(array, key) >= 0;
}

这个解决方案还有一个副作用：它修改了 array （排序）。

我知道已经很晚了，但是试试看 Integer[] 而不是 int[] .

是因为 Arrays.asList(array) 返回 List<int[]> . array 参数被视为要 Package 的一个值（得到int数组的列表），而不是vararg。
请注意，它确实适用于对象类型（而不是基本体）：

public boolean contains(final String[] array, final String key) {
    return Arrays.asList(array).contains(key);
}

甚至：

public <T>  boolean contains(final T[] array, final T key) {
    return Arrays.asList(array).contains(key);
}

但你不能 List<int> 自动装箱在这里不起作用。

下面是Java8解决方案

public static boolean contains(final int[] arr, final int key) {
    return Arrays.stream(arr).anyMatch(i -> i == key);
}

你可以用 java.util.Arrays 类来转换数组 T[?] 在一个 List<T> 对象的方法，如 contains :

Arrays.asList(int[] array).contains(int key);

根据int数组的大小，如果使用集合和 .contains 而不是一次迭代数组中的一个元素：

import static org.junit.Assert.assertTrue;
import java.util.HashSet;

import org.junit.Before;
import org.junit.Test;

public class IntLookupTest {

int numberOfInts = 500000;
int toFind = 200000;
int[] array;

HashSet<Integer> intSet;

@Before
public void initializeArrayAndSet() {
    array = new int[numberOfInts];
    intSet = new HashSet<Integer>();
    for(int i = 0; i < numberOfInts; i++) {
        array[i] = i;
        intSet.add(i);
    }
}

@Test
public void lookupUsingCollections() {
    assertTrue(intSet.contains(toFind));
}

@Test
public void iterateArray() {
    assertTrue(contains(array, toFind));

}

public boolean contains(final int[] array, final int key) {
    for (final int i : array) {
        if (i == key) {
            return true;
        }
    }
    return false;
}
}

这在Java8中起作用

public static boolean contains(final int[] array, final int key)
{
return Arrays.stream(array).anyMatch(n->n==key);
}

你可以用 ArrayUtils.contains 从 Apache Commons Lang library .

public boolean contains(final int[] array, final int key) {     
    return ArrayUtils.contains(array, key);
}

尝试 Integer.parseInt() 为此。。。。。

public boolean chkInt(final int[] array){
    int key = false;

    for (Integer i : array){

          try{

                   Integer.parseInt(i);
                   key = true;
                   return key;

             }catch(NumberFormatException ex){

                   key = false;

                   return key;

              }

     }
}

guava为原始类型提供了额外的方法。其中包含一个方法，该方法采用与您相同的参数。

public boolean contains(final int[] array, final int key) {
    return Ints.contains(array, key);
}

您不妨静态地导入guava版本。
见Guava原语解释

另一种方式：

public boolean contains(final int[] array, final int key) {  
     Arrays.sort(array);  
     return Arrays.binarySearch(array, key) >= 0;  
}

这将修改传入的数组。您可以选择复制数组并处理原始数组，即。 int[] sorted = array.clone(); 但这只是一个简短代码的例子。运行时是 O(NlogN) 当你的方式是 O(N)

1.一次性使用

List<T> list=Arrays.asList(...)
list.contains(...)

2.如果您使用多次，请出于性能考虑使用hashset。

Set <T>set =new HashSet<T>(Arrays.asList(...));
set.contains(...)

试试这个：

public static void arrayContains(){
    int myArray[]={2,2,5,4,8};

    int length=myArray.length;

    int toFind = 5;
    boolean found = false;

    for(int i = 0; i < length; i++) {
        if(myArray[i]==toFind) {
            found=true;
        }
    }

    System.out.println(myArray.length);
    System.out.println(found); 
}