Java，簡化檢查 int 數組是否包含 int

Question

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

有人可以幫我嗎？

謝謝你。

Answer 1

您可以簡單地使用 Apache Commons Lang 庫中的ArrayUtils.contains 。

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

Answer 2

這是 Java 8 解決方案

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

Answer 3

這是因為Arrays.asList(array)返回List<int[]> 。 array參數被視為您想要包裝的一個值（您將獲得一個整數數組列表），而不是作為可變參數。

請注意，它確實適用於對象類型（不是基元）：

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>並且自動裝箱在這里不起作用。

Answer 4

Guava 為原始類型提供了額外的方法。 其中有一個 contains 方法，它采用與您相同的參數。

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

您不妨靜態導入番石榴版本。

見番石榴原語解釋

Answer 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)

Answer 6

我知道這太晚了，但請嘗試Integer[]而不是int[] 。

Answer 7

您可以使用以下 Java 8 代碼將原始 int 數組轉換為整數數組列表，

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

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

boolean containsElement = arrayElementsList.contains(key);

Answer 8

1.一次性使用

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

2.如果多次使用，為了性能考慮，使用HashSet。

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

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

Answer 10

您可以使用java.util.Arrays類使用contains方法轉換List<T>對象中的數組T[?] ：

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

Answer 11

這在java 8中有效

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

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

Answer 13

Java 9+

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

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

Answer 15

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

有人可以幫我嗎？

謝謝你。

Answer 16

嘗試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;

              }


     }
}