arrays array - Java,Simplified检查int数组是否包含int




contains (12)

基本上我的伙伴一直说我可以通过使用不同的方式检查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);
}

任何人都可以帮我吗?

谢谢。


Answers

我知道这是最晚的,但尝试Integer[]而不是int[]


解决方案#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 (对其进行排序)。


这在java 8中有效

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

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

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

这是因为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>并且autoboxing在这里不起作用。


Guava为原始类型提供了其他方法。 其中包含一个与您的参数相同的contains方法。

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

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

参见番石榴原始解释


一次性使用

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

2.如果您使用多次,请使用HashSet进行性能考虑。

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

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

如果数组是int,double或long,我们可以分别使用这些IntStream,DoubleStream或LongStream

int[] values = { 1, 33, 55, 66 };
int testValue = 33;
boolean contains = IntStream.of(values).anyMatch(x -> x == testValue);

参考 - 检查Array中的值


另一种方式:

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)


这是Java 8解决方案

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

if needle in haystack:正常使用,正如@Michael所说 - 它依赖于in运算符,比方法调用更可读,更快。

如果你真的需要一个方法而不是一个操作符(例如做一些奇怪的key=非常奇怪的那种......?),那就是'haystack'.__contains__ 。 但是因为你的例子是用于if ,我想你并不是真的意思是你说的;-)。 直接使用特殊方法不是好形式(也不可读,也不高效) - 而是通过委托给它们的运算符和内置函数来使用它们。





java arrays int contains