Java: compruebe si la matriz contiene valor o elemento

     

    Introducción

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

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

    • Arrays.asList (). Contiene ()
    • Usando un bucle for
    • Colecciones.binarySearch ()
    • API de Java 8 Stream
    • Apache Commons – ArrayUtils

    Arrays.asList (). Contiene ()

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

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

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

    Matriz de un Integer tipo:

    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:

    false
    true
    

    Usando un bucle for

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

    Comencemos primero con enteros primitivos:

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

    los found La variable se establece inicialmente en false porque la unica forma de volver true sería encontrar el elemento y asignar explícitamente un nuevo valor al booleano. Aquí, simplemente comparamos cada elemento de la matriz con el valor que estamos buscando y devolvemos true si coinciden:

    true
    

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

    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 resultará en:

    false
    

    Colecciones.binarySearch ()

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

    Si no está ordenado, el tiempo adicional necesario para ordenar la matriz puede 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:

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

    Dónde 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 el 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:

    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 dará como resultado:

    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 de retorno es -(insertion point)-1, por lo que el valor de retorno termina siendo -6.

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

    API de Java 8 Stream

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

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

    Integer[] arr = new Integer[]{1, 2, 3, 4, 5};
    
    System.out.println(Arrays.stream(arr).anyMatch(x -> x == 3));
    

    Esto dará como resultado:

    true
    

    Y para hacer esto con Strings u objetos personalizados:

    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 puede acortarlo utilizando una referencia de método:

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

    Ambos generarían:

    false
    

    Apache Commons – ArrayUtils

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

    los ArrayUtils La clase presenta muchos métodos para manipular matrices, incluida la contains() método:

    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:

    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. Hemos repasado la conversión de la matriz en una lista y hemos llamado al contains() método, usando un bucle for, la API de Java 8 Stream, así como Apache Commons.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *