Java: compruebe si la matriz contiene valor o elemento

En este tutorial, repasaremos ejemplos de cómo comprobar si una matriz de Java contiene un determinado elemento o valor. Usaremos una lista, la API de transmisión y Apache Commons.

Introducción

Ya sea en Java o en cualquier otro lenguaje de programación, es común verificar si una matriz contiene un valor. Esta es una de las cosas que la mayoría de los principiantes tienden a aprender, y en general es algo útil saberlo.

En este artículo, veremos cómo verificar si una matriz contiene un valor o elemento en Java.

Arrays.asList().contains()

Esta es quizás la forma más común de resolver este problema, simplemente porque funciona muy bien y es fácil de implementar.

Primero, convertimos la matriz en una ArrayList. Hay varias formas de convertir una matriz de Java en una ArrayList, sin embargo, usaremos el enfoque más utilizado.

Luego, podemos usar el método contains() en la ArrayList resultante, que devuelve un valor booleano que indica si la lista contiene el elemento que le hemos pasado o no.

Array de un tipo Integer:

1
2
3
4
5
6
7
8
Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{"John", "Mark", "Joe", "Bill", "Connor"};

List<Integer> intList = new ArrayList<>(Arrays.asList(intArray));
List<String> nameList = new ArrayList<>(Arrays.asList(nameArray));

System.out.println(intList.contains(12));
System.out.println(nameList.contains("John"));

Ejecutar este código da como resultado:

1
2
false
true

Usar un bucle for

Un enfoque más básico y manual para resolver el problema es usar un bucle for. En el peor de los casos, iterará toda la matriz una vez, verificando si el elemento está presente.

Comencemos primero con los enteros primitivos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
int[] intArray = new int[]{1, 2, 3, 4, 5};
boolean found = false;
int searchedValue = 2;

for(int x : intArray){
    if(x == searchedValue){
        found = true;
        break;
    }
}

System.out.println(found);

La variable encontrado se establece inicialmente en falso porque la única forma de devolver verdadero sería encontrar el elemento y asignar explícitamente un nuevo valor al valor booleano. Aquí, simplemente comparamos cada elemento de la matriz con el valor que estamos buscando y devolvemos true si coinciden:

1
true

Para cadenas y objetos personalizados que pueda tener en su código, estaría usando un operador de comparación diferente. Suponiendo que haya invalidado válidamente el método equals(), puede usarlo para verificar si un objeto es igual a otro, devolviendo true si lo son:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
String[] stringArray = new String[]{"John", "Mark", "Joe", "Bill", "Connor"};
boolean found = false;
String searchedValue = "Michael";

for(String x : stringArray){
    if(x.equals(searchedValue)){
        found = true;
        break;
    }
}

System.out.println(found);

Ejecutar este código dará como resultado:

1
false

Colecciones.binarySearch()

Además, podemos encontrar un valor específico usando un método integrado binarySearch() de la clase Collections. El problema con la búsqueda binaria es que requiere que nuestra matriz esté ordenada. Sin embargo, si nuestra matriz está ordenada, binarySearch() supera tanto a Arrays.asList().contains() como a los enfoques de bucle for.

Si no está ordenada, el tiempo adicional requerido para ordenar la matriz podría hacer que este enfoque sea menos favorable, según el tamaño de la matriz y el algoritmo de clasificación utilizado para ordenarla.

binarySearch() tiene muchas variantes sobrecargadas según los tipos utilizados y nuestros propios requisitos, pero la más general es:

1
public static int binarySearch(Object[] a, Object[] key)

Donde a representa la matriz y key el valor especificado que estamos buscando.

Ahora, el valor de retorno puede ser un poco confuso, por lo que es mejor tener en cuenta la documentación oficial de Oracle:

El valor de retorno de este método es el índice de la clave buscada, si está contenida en la matriz; de lo contrario (-(punto de inserción) - 1), donde punto de inserción se define como el punto en el que se insertaría la clave en la matriz: el índice del primer elemento mayor que la clave, o a.length si todos los elementos de la matriz son menores que la clave especificada.

Probemos esto:

1
2
3
4
5
6
7
Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{"Bill", "Connor", "Joe", "John", "Mark"}; // Array is already sorted lexicographically

List<Integer> intList = new ArrayList<>(Arrays.asList(intArray));
List<String> nameList = new ArrayList<>(Arrays.asList(nameArray));
System.out.println(Collections.binarySearch(intList, 2));
System.out.println(Collections.binarySearch(nameList, "Robin"));

Esto generará:

1
2
1
-6

El primer elemento se encuentra en la posición 1. El segundo elemento no se encuentra y se insertaría en la posición 5, al final de la matriz. El valor devuelto es -(punto de inserción)-1, por lo que el valor devuelto termina siendo -6.

Si el valor es igual o superior a 0, la matriz contiene el elemento y, de lo contrario, no lo contiene.

API de flujo de Java 8

La API de flujo de Java 8 es muy versátil y ofrece soluciones concisas para varias tareas relacionadas con el procesamiento de colecciones de objetos. Usar Streams para este tipo de tareas es natural e intuitivo para la mayoría.

Echemos un vistazo a cómo podemos usar Stream API para verificar si una matriz contiene un número entero:

1
2
3
Integer[] arr = new Integer[]{1, 2, 3, 4, 5};

System.out.println(Arrays.stream(arr).anyMatch(x -> x == 3));

Esto generará:

1
true

Y para hacer esto con Strings u objetos personalizados:

1
2
3
4
5
6
7
8
String[] arr = new String[]{"John", "Mark", "Joe", "Bill", "Connor"};

String searchString = "Michael";

boolean doesContain = Arrays.stream(arr)
        .anyMatch(x -> x.equals(searchString));

System.out.println(doesContain);

O bien, puede acortarlo utilizando una referencia de método:

1
2
3
4
boolean doesContain = Arrays.stream(arr)
        .anyMatch(searchString::equals);
        
System.out.println(doesContain);

Ambos darían salida:

1
false

Apache Commons - ArrayUtils

La biblioteca Apache Commons proporciona muchas interfaces, implementaciones y clases nuevas que se expanden en el núcleo de Java Framework y está presente en muchos proyectos.

La clase ArrayUtils presenta muchos métodos para manipular matrices, incluido el método contains():

1
2
3
4
5
Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{"John", "Mark", "Joe", "Bill", "Connor"};

System.out.println(ArrayUtils.contains(intArray, 3));
System.out.println(ArrayUtils.contains(nameArray, "John"));

Esto daría como resultado:

1
2
true
true

Conclusión

En este artículo, hemos repasado varias formas de verificar si una matriz en Java contiene un determinado elemento o valor. Repasamos la conversión de la matriz en una lista y llamamos al método contains(), utilizando un bucle for, la API de flujo de Java 8, así como Apache Commons.

Licensed under CC BY-NC-SA 4.0