Java, verificación simplificada si la matriz int contiene int

Básicamente, mi amigo ha estado diciendo que podría acortar mi código usando una forma diferente de verificar si una matriz int contiene un int, aunque no me dirá qué es: P.

Actual:

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

También he probado esto, aunque siempre devuelve falso por alguna razón.

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

¿Podría alguien ayudarme?

Gracias.

Aquí está la solución Java 8

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

Simplemente podría usar ArrayUtils.containsfrom Apache Commons Lang library.

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

Es porque Arrays.asList(array)regresa List<int[]>. arrayEl argumento se trata como un valor que desea ajustar (obtiene una lista de matrices de entradas), no como vararg.

Nota que hace el trabajo con los tipos de objetos primitivos (no):

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

o incluso:

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

Pero no puede tener List<int>y el autoboxing no funciona aquí.

Guayaba ofrece métodos adicionales para tipos primitivos. Entre ellos, un método contiene que toma los mismos argumentos que el suyo.

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

También puede importar estáticamente la versión de guayaba.

Ver la explicación de los primitivos de guayaba

De otra manera:

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

Esto modifica la matriz pasada. Tendría la opción de copiar la matriz y trabajar en la matriz original, es decir, int[] sorted = array.clone();
pero esto es solo un ejemplo de código corto. El tiempo de ejecución es O(NlogN)mientras tu camino esO(N)

Sé que es muy tarde, pero inténtalo en Integer[]lugar de hacerlo int[].

Usos únicos

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

2.use HashSet para considerar el rendimiento si lo usa más de una vez.

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

Prueba esto:

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

Puede convertir su matriz int primitiva en una lista de matrices de enteros usando el siguiente código de Java 8,

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

Y luego use el contains()método para verificar si la lista contiene un elemento en particular,

boolean containsElement = arrayElementsList.contains(key);

esto funcionó en java 8

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

Puede usar la java.util.Arraysclase para transformar la matriz T[?]en un List<T>objeto con métodos como contains:

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

Dependiendo de qué tan grande sea su matriz de int, obtendrá un rendimiento mucho mejor si usa colecciones y en .containslugar de iterar sobre la matriz un elemento a la 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;
}
}

Solución # 1

Dado que la pregunta original solo quiere una solución simplificada (y no una más rápida), aquí hay una solución de una línea:

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

Explicación: Javadoc de Arrays.toString()estados que el resultado está entre corchetes y los elementos adyacentes están separados por los caracteres "," (una coma seguida de un espacio). Entonces podemos contar con esto. Primero convertimos arraya una cadena, y luego verificamos si keyestá contenida en esta cadena. Por supuesto, no podemos aceptar "subnúmeros" (por ejemplo, "1234" contiene "23"), así que tenemos que buscar patrones en los que keyesté precedido por un corchete de apertura o un espacio, y seguido por un corchete de cierre o una coma.

Nota: El patrón de expresiones regulares utilizado también maneja correctamente los números negativos (cuya representación de cadena comienza con un signo menos).

Solución # 2

Esta solución ya está publicada pero contiene errores, así que publico la solución correcta:

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

Además, esta solución tiene un efecto secundario: modifica el array(lo ordena).

Intenta Integer.parseInt()hacer esto .....

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;

              }


     }
}