【问题标题】：Java, Simplified check if int array contains intJava，简化检查 int 数组是否包含 int
【发布时间】：2012-08-14 18:17:29
【问题描述】：

基本上，我的伙伴一直在说，我可以通过使用不同的方式检查 int 数组是否包含 int 来缩短我的代码，尽管他不会告诉我它是什么：P。

当前：

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

也试过这个，尽管由于某种原因它总是返回 false。

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

谁能帮帮我？

谢谢。

【问题讨论】：

您的 Arrays.asList(...) 调用需要一个可变参数，也就是说，它会将您可能传入的任意数量的参数包装在一个列表中。在您的情况下，您将获得一个包含单个元素的数组列表，而该列表显然不包含 int。
你的评论现在意味着什么？
检查Hashset基于重审机制的答案。这是最快的方式。
我认为缩短原始代码没有任何意义，因为您的参数是一个原始数组，而且您的代码非常清晰和直截了当。 ArrayList 实现也是如此。
我不会让你的代码更短。 (1) arraylist 做同样的事情。 (2) - 更重要的是使用 Arrays.asList 的缩短代码创建了新对象，这可能是一些性能关键代码中的问题。第一个代码 sn -p 是你能做的最好的事情。

标签： java arrays int contains

【解决方案1】：

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

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

【讨论】：

只要你用的是ArrayUtils，有什么理由不用ArrayUtils.contains
没有任何理由:)
值得注意的是ArrayUtils.contains() 是Apache Commons Lang 库的一部分。即使这是一个很棒的库，添加外部依赖项只是为了检查数组是否包含元素可能仍然不是一个好主意：D
ArrayUtils 已成为过去。 Java 8+ 和 Guava 有非常棒的好东西！！

【解决方案2】：

这里是 Java 8 解决方案

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

【讨论】：

请注意，此调用需要 API 级别 24

【解决方案3】：

这是因为Arrays.asList(array) 返回List<int[]>。 array 参数被视为您要包装的一个值（您会得到一个整数数组列表），而不是 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>，并且自动装箱在这里不起作用。

【讨论】：

为什么自动装箱不起作用，是因为它被声明为final？

【解决方案4】：

Guava 为原始类型提供了额外的方法。其中有一个 contains 方法，它采用与您相同的参数。

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

你不妨静态导入番石榴版本。

见Guava Primitives Explained

【讨论】：

【解决方案5】：

另一种方式：

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)

【讨论】：

如果contains 方法修改了我的数组，我想我会感到惊讶。
@ZongLi：这只是 OP 的一个例子。如果我们吹毛求疵，更新 OP
来自 binarySearch() 的 javadoc：“当且仅当找到键时，返回值将 >= 0。”所以应该返回 Arrays.binarySearch(array,key)>=0！
补充：binarySearch()的返回值为(-(insertion point) - 1)，如果key不包含，可能是-1以外的值。
这不可能是-1，如果它是真的。 “插入点定义为将键插入列表的点：第一个元素的索引大于键，如果列表中的所有元素都小于指定的键，则为 list.size()。 ”。需要说>= 0。

【解决方案6】：

我知道现在已经很晚了，但请尝试使用 Integer[] 而不是 int[]。

【讨论】：

这就是解决方案。

【解决方案7】：

1.一次性使用

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

2.如果多次使用，请使用 HashSet 来考虑性能。

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

【讨论】：

【解决方案8】：

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

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

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

boolean containsElement = arrayElementsList.contains(key);

【讨论】：

【解决方案9】：

试试这个：

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

【讨论】：

【解决方案10】：

这在 java 8 中有效

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

【讨论】：

它应该在第一次匹配时立即返回，而不是它仍然会扫描数组中的所有项目，即使它确实找到了匹配项。（考虑一个包含万亿项的数组）
你是对的，试试这个 public static boolean contains(final int[] array, final int key) { return Arrays.stream(array).anyMatch(n->n==key); }
Java 8 流 anyMatch 是一个short-circuit operation，不会扫描数组中的所有项目。
@LordParsley 以上代码的目标是检查数组中的元素，而不是扫描数组的所有元素。
抱歉，我看到答案已被编辑。我只是重申它是正确的，因为如果它找到一个部分，它就不需要扫描所有。

【解决方案11】：

您可以使用java.util.Arrays 类通过contains 之类的方法将数组T[?] 转换为List<T> 对象：

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

【讨论】：

【解决方案12】：

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

【讨论】：

【解决方案13】：

Java 9+

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

【讨论】：

【解决方案14】：

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

【讨论】：

【解决方案15】：

尝试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;

              }


     }
}

【讨论】：