小开

这是因为 Arrays.asList(array)返回 List<int[]>。array参数被视为要换行的一个值(得到整型数组的列表) ，而不是 vararg。

请注意，是的处理对象类型(而不是原语) :

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

or even:

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

但是你不能有 List<int>和自动装箱是不工作在这里。

小开

A different way:

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)

小开

您可以简单地使用 Apache Commons Lang 库中的 ArrayUtils.contains。

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;


}




}
}

小开

根据 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;
}
}

小开

Guava 为基本类型提供了其他方法，其中一个包含的方法与您的方法具有相同的参数。

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

You might as well statically import the guava version.

参见番石榴原始解释

小开

一次过使用

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

2. 如果使用多次，则使用 HashSet 进行性能考虑。

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

小开

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

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

小开

我知道现在很晚了，但试试 Integer[]而不是 int[]。

小开

最佳答案

这是 Java8解决方案

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

小开

这在 java 8中有效

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

小开

Try this:

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

小开

您可以使用以下 Java8代码将原始 int 数组转换为 Integers 数组列表,

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

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

boolean containsElement = arrayElementsList.contains(key);

小开

private static void solutions() {
int[] A = { 1, 5, 10, 20, 40, 80 };
int[] B = { 6, 7, 20, 80, 100 };
int[] C = { 3, 4, 15, 20, 30, 70, 80, 120 };


List<Integer> aList = Arrays.stream(A).boxed().collect(Collectors.toList());


List<Integer> cList = Arrays.stream(C).boxed().collect(Collectors.toList());
String s = "";
for (Integer a : C) {
if (aList.contains(a) && cList.contains(a)) {
s = s.concat(String.valueOf(a)).concat("->");
}
}
}

小开

Java9 +

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

简化检查 int 数组是否包含 int

Java9 +