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

基本上，我的同伴一直在说，我可以使用另一种检查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);
}

有人可以帮我吗？

谢谢。

这是Java 8解决方案

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

您可以简单地使用ArrayUtils.containsfrom Apache Commons Lang library。

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

这是因为Arrays.asList(array)return 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>并且自动装箱在这里不起作用。

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

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

您也可以静态导入番石榴版本。

参见解释番石榴基元

另一种方式：

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)

我知道这太迟了，但是请尝试Integer[]代替int[]。

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

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

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

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

boolean containsElement = arrayElementsList.contains(key);

这在Java 8中工作

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

解决方案1

由于最初的问题只需要一种简化的解决方案（而不是更快的解决方案），因此这里是一线解决方案：

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

说明：Arrays.toString()状态的Javadoc 结果用方括号括起来，相邻的元素用字符“，”（逗号后跟空格）分隔。因此，我们可以指望这一点。首先，我们转换array为字符串，然后检查key此字符串中是否包含。当然，我们不能接受“子数字”（例如，“ 1234”包含“ 23”），因此我们必须寻找这样的模式，在模式key前加一个中括号或一个空格，后跟一个中括号或逗号。

注意：使用的正则表达式模式也可以正确处理负数（其字符串表示形式以减号开头）。

解决方案＃2

该解决方案已经发布，但是包含错误，因此我发布了正确的解决方案：

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

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

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

              }


     }
}