Compruebe si existe una clave particular en Java HashMap

HashMap en Java es la realización de una especie de estructura de datos Hash Table. Se compone de pares de clave y valor que se representan simbólicamente como <K,V> donde K representa clave y V valor. Es una implementación de la interfaz de Maps y es ventajoso en la forma en que proporciona un rendimiento de tiempo constante en la asignación y el acceso a elementos a través de los métodos put y get respectivamente. Se utiliza para formar parejas asociadas y acceder o modificar una en función de la otra. 

Hay varios enfoques para verificar si existe una clave en particular que se mencionan a continuación:

• Usando el método integrado containsKey() de la clase HashMap
• Convertir las claves del HashMap en una lista y luego iterar a través de ellas
• Crear un mapa a partir de todas las entradas del HashMap y luego iterarlo

Enfoque 1:

Usando este enfoque, hacemos uso del método predefinido containsKey() de la clase HashMap que devuelve un valor booleano.

Sintaxis:

Hash_Map.containsKey(key_element)

Parámetros: el método toma solo un parámetro key_element que se refiere a la clave cuyo mapeo se supone que debe verificarse dentro de un mapa.

Valor devuelto: el método devuelve un valor booleano verdadero si se detecta la presencia de la clave; de ​​lo contrario, es falso

Algoritmo:

1. Cree una función con un tipo de retorno booleano.
2. Dentro de la función, cree un nuevo HashMap especificando los tipos de datos de la clave y el valor respectivamente.
3. Rellene el HashMap con pares clave-valor utilizando el método put() de la clase HashMap.
4. Declare una variable booleana para almacenar el resultado.
5. Llame al método containsKey() de la clase HashMap con la clave que se verificará como parámetro.
6. Devuelve la variable.

Código:

// java program to check if a particular
// key exists in HashMap
 
import java.util.*;
 
class GFG {
 
    // declaring the method
    // the parameter keyToBeChecked is the
    // key to be checked
    boolean checkForKey(String keyToBeChecked)
    {
 
        // initializing the hashmap
        HashMap<String, Integer> hashMap =
          new HashMap<>();
 
        // filling the key - value pairs in hashmap
        hashMap.put("first", 1);
        hashMap.put("second", 2);
        hashMap.put("third", 3);
        hashMap.put("fourth", 4);
 
        // variable to store the boolean value
        // for result
        boolean result
            = hashMap.containsKey(keyToBeChecked);
 
        // returning the result
        return result;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // displaying and calling the checkForKey()
        // method
        System.out.println(ob.checkForKey("fourth"));
    }
}

true

Enfoque 2:

Creamos una ArrayList a partir de las claves del HashMap y luego iteramos sobre ellas para verificar si la clave especificada está presente o no.

Algoritmo: 

1. Repita los pasos 1 a 3 como se mencionó en el primer enfoque.
2. A continuación, inicializamos una ArrayList del mismo tipo de datos que las claves del HashMap utilizando el método predefinido keySet() de la clase HashMap.
3. Para el siguiente paso, declaramos un iterador para iterar a través de los elementos del ArrayList creado anteriormente.
4. Luego iteramos a través de ArrayList verificando en cada iteración si la clave particular coincide con alguno de los elementos de ArrayList creados anteriormente.
5. Devuelve la salida correspondiente.

Código:

// java program to check if a particular
// key exists in the HashMap
 
import java.util.*;
 
class GFG {
 
    // declaring the method
    // the parameter keyToBeChecked is
    // the key to be checked
    boolean checkForKey(String keyToBeChecked)
    {
 
        // initializing the HashMap
        HashMap<String, Integer> hashMap =
          new HashMap<>();
 
        // filling the key-value pairs
        // in the HashMap
        hashMap.put("first", 1);
        hashMap.put("second", 2);
        hashMap.put("third", 3);
        hashMap.put("fourth", 4);
 
        // creating an ArrayList from the keys
        ArrayList<String> listOfKeys
            = new ArrayList<>(hashMap.keySet());
 
        // declaring the iterator
        Iterator<String> itr = listOfKeys.iterator();
 
        // loop to iterate through the
        // elements of the ArrayList
        while (itr.hasNext()) {
 
            // condition to check against
            // the specific key
            if (itr.next() == keyToBeChecked)
                return true;
        }
        return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // displaying and calling the
        // checkForKey method
        System.out.println(ob.checkForKey("second"));
    }
}

true

Enfoque 3:

Iteramos sobre las claves comprobando si la especificada está presente o no.

Algoritmo: 

1. Repita los pasos 1 a 3 en el primer enfoque para crear un HashMap.
2. Usando un bucle for each y el método predefinido entrySet() de la clase HashMap, cree un mapa del mismo.
3. En cada iteración del bucle for, obtenga una clave del mapa creado anteriormente utilizando el método integrado getKey() de la clase Map.
4. Compáralo con la clave especificada.
5. Devuelve verdadero si la clave coincide con alguno de los elementos del conjunto de claves o, de lo contrario, devuelve falso.

Código: 

// java program to check if a particular
// key exists in the HashMap
 
import java.util.*;
 
class GFG {
 
    // declaring the method
    // the parameter keyToBeChecked specifies
    // the particular key
    boolean checkForKey(String keyToBeChecked)
    {
 
        // initializing the HashMap
        HashMap<String, Integer> hashMap = new HashMap<>();
 
        // filling up the key-value
        // pairs in the HashMap
        hashMap.put("first", 1);
        hashMap.put("second", 2);
        hashMap.put("third", 3);
        hashMap.put("fourth", 4);
 
        // initializing the for each loop
        // using which the entries of the
        // HashMap are stored in a Set
        for (Map.Entry<String, Integer> mapEntries :
             hashMap.entrySet()) {
 
            // getting the keys and checking
            // against the specified key
            if (mapEntries.getKey() == keyToBeChecked)
                return true;
        }
        return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // displaying and calling the
        // checkForKey method
        System.out.println(ob.checkForKey("seventh"));
    }
}

false