Java, verificação simplificada se o array int contém int

Basicamente, meu amigo tem dito que eu poderia tornar meu código mais curto usando uma maneira diferente de verificar se um array int contém um int, embora ele não me diga o que é: P.

Atual:

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

Também tentei fazer isso, embora sempre retorne falso por algum motivo.

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

Alguém poderia me ajudar?

Obrigado.

Aqui está a solução Java 8

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

Você pode simplesmente usar ArrayUtils.containsde Apache Commons Lang library.

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

É porque Arrays.asList(array)volte List<int[]>. arrayargumento é tratado como um valor que você deseja agrupar (você obtém uma lista de arrays de ints), não como vararg.

Note-se que ele faz o trabalho com tipos de objeto (não primitivos):

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

ou mesmo:

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

Mas você não pode ter List<int>e autoboxing não está funcionando aqui.

O Guava oferece métodos adicionais para tipos primitivos. Entre eles, um método contém que leva os mesmos argumentos que o seu.

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

Você também pode importar estaticamente a versão goiaba.

Veja os primitivos de goiaba explicados

Uma maneira diferente:

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

Isso modifica a matriz passada. Você teria a opção de copiar o array e trabalhar no array original, ou seja, int[] sorted = array.clone();
mas este é apenas um exemplo de código curto. O tempo de execução é O(NlogN)enquanto o seu caminho éO(N)

Eu sei que é muito tarde, mas tente em Integer[]vez de int[].

1. usos únicos

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

2. use HashSet para consideração de desempenho se você usar mais de uma vez.

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

Experimente isto:

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

Você pode converter sua matriz primitiva int em uma lista de números inteiros usando o código Java 8 abaixo,

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

E então use o contains()método para verificar se a lista contém um elemento específico,

boolean containsElement = arrayElementsList.contains(key);

isso funcionou em java 8

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

Você pode usar a java.util.Arraysclasse para transformar a matriz T[?]em um List<T>objeto com métodos como contains:

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

Dependendo de quão grande será a sua matriz de int, você obterá um desempenho muito melhor se usar coleções e em .containsvez de iterar na matriz um elemento por vez:

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

Solução # 1

Uma vez que a pergunta original deseja apenas uma solução simplificada (e não mais rápida), aqui está uma solução de uma linha:

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

Explicação: Javadoc de Arrays.toString()estados, o resultado é colocado entre colchetes e os elementos adjacentes são separados pelos caracteres "," (uma vírgula seguida por um espaço). Portanto, podemos contar com isso. Primeiro, convertemos arraypara uma string e, em seguida, verificamos se keyessa string está contida. Claro que não podemos aceitar "subnúmeros" (por exemplo, "1234" contém "23"), então temos que procurar padrões onde o keyseja precedido por um colchete de abertura ou um espaço e seguido por um colchete de fechamento ou vírgula.

Nota: O padrão regexp usado também lida corretamente com números negativos (cuja representação de string começa com um sinal de menos).

Solução # 2

Esta solução já foi postada mas contém erros, então posto a solução correta:

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

Além disso, esta solução tem um efeito colateral: ela modifica o array(ordena).

Tente Integer.parseInt()fazer isso ...

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;

              }


     }
}