Compruebe si existe un valor particular en Java HashMap

Java HashMap es una implementación de la interfaz de mapa que asigna un valor a una clave que esencialmente forma un par asociativo en el que podemos llamar a un valor basado en la clave. Java HashMap ofrece muchas ventajas, como permitir diferentes tipos de datos para la clave y el valor, lo que hace que esta estructura de datos sea más inclusiva y versátil. También permite nulo para la Clave y el Valor dado que uno de los dos que forman un par no es nulo.

Los diferentes enfoques para verificar la existencia de un Valor particular en un HashMap de Java son:

1. Usando el método integrado containsValue() de la clase HashMap
2. Crear un mapa a partir de las entradas de HashMap y luego iterar a través de los Valores
3. Crear una ArrayList a partir de los valores de HashMap y luego iterar a través de esta lista

Enfoque 1:

Este enfoque proporciona un método bastante simple y eficiente para comprobar la existencia de un valor en un HashMap utilizando el método predefinido containsValue() que devuelve un valor booleano.

Sintaxis:

Hash_Map.containsValue(Object Value)

Parámetros: el método toma solo un parámetro Valor de tipo Objeto y se refiere al valor cuyo mapeo se supone que debe verificar cualquier tecla dentro del mapa.

Valor devuelto: el método devuelve un valor booleano verdadero si se detecta la asignación del valor; de lo contrario, es falso.

Algoritmo:

1. Declare un método con tipo de retorno booleano para verificar la existencia del valor.
2. Inicialice un HashMap que describa los tipos de datos para la clave y los valores.
3. Rellene este HashMap con pares clave-valor utilizando el método put() integrado de la clase HashMap.
4. Declare una variable booleana para almacenar el resultado del método containsValue().

Código:

// java program to check if a particular
// value exists in a HashMap
 
import java.util.*;
 
class GFG {
 
    // declaring the method to return
    // if the value is present or not
    // the parameter valueToBeChecked
    // represents the value to be checked
    boolean checkForValue(int valueToBeChecked)
    {
 
        // initializing the HashMap
        HashMap<String, Integer> hashMap = new HashMap<>();
 
        // filling the HashMap with
        // key value pairs
        hashMap.put("key1", 1);
        hashMap.put("key2", 2);
        hashMap.put("key3", 3);
        hashMap.put("key4", 4);
 
        // declaring the variable to store
        // the result
        // calling the containsValue() method
        boolean result
            = hashMap.containsValue(valueToBeChecked);
 
        // returning the result
        return result;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // displaying and calling the
        // checkForValue() method
        System.out.println(ob.checkForValue(10));
    }
}

false

Enfoque 2:

Usando este enfoque, creamos un mapa a partir de todas las entradas de HashMap, claves y valores incluidos y luego iteramos solo a través de los valores para verificar el específico.

Algoritmo:

1. Repita los pasos 1 a 3 como se describe en el primer enfoque para crear un HashMap.
2. A continuación, cree un mapa utilizando un bucle for each y el método entrySet() predefinido de HashMap.
3. Iterar a través de los valores en el Mapa utilizando el método getValue() predefinido de la clase Mapa.
4. En cada iteración, compare el valor con el valor especificado y devuelva el resultado correspondiente.

Código:

// java program to check if a particular
// value exists in HashMap
 
import java.util.*;
 
class GFG {
 
    // declaring the method
    // the parameter is the variable which
    // stores the value to be checked
    boolean checkForValue(int valueToBeChecked)
    {
 
        // initializing the HashMap
        HashMap<String, Integer> hashMap = new HashMap<>();
 
        // filling up the HashMap with
        // Key-Value pairs
        hashMap.put("key1", 1);
        hashMap.put("key2", 2);
        hashMap.put("key3", 3);
        hashMap.put("key4", 4);
 
        // for each loop
        // all the entries in the HashMap are
        // stored in the Map
        for (Map.Entry<String, Integer> mapEntries :
             hashMap.entrySet()) {
 
            // fetching the values of the HashMap
            // one at a time and comparing with
            // the value to be checked
            if (mapEntries.getValue() == valueToBeChecked)
                return true;
        }
        return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // displaying and calling the
        // checkForValue() method
        System.out.println(ob.checkForValue(2));
    }
}

true

Enfoque 3:

Bajo el tercer enfoque, creamos un ArrayList a partir de los valores de HashMap e iteramos a través de la lista completa para verificar el valor específico mencionado.

Algoritmo:

1. Repita los pasos 1 a 3 para crear un HashMap.
2. A continuación, cree una ArrayList del mismo tipo de datos que los valores en HashMap.
3. En el siguiente paso, declaramos un iterador para recorrer toda la ArrayList hasta que encuentre el valor específico.
4. Usando un bucle while itere a través de los valores almacenados en ArrayList y en cada iteración verifique con el valor especificado.
5. Devuelve el resultado correspondiente como un valor booleano.

Código:

// java program to check if a particular
// key exists in a HashMap
 
import java.util.*;
 
class GFG {
 
    // declaring the method
    // the parameter specifies the value to
    // be checked
    boolean checkForValue(int valueToBeChecked)
    {
 
        // initializing the HashMap
        HashMap<String, Integer> hashMap = new HashMap<>();
 
        // filling up the HashMap with
        // Key-Value pairs
        hashMap.put("key1", 1);
        hashMap.put("key2", 2);
        hashMap.put("key3", 3);
        hashMap.put("key4", 4);
 
        // declaring an ArrayList of type
        // Integer from the values of the
        // HashMap using the predefined
        // values() method of the HashMap class
        ArrayList<Integer> listOfValues
            = new ArrayList<>(hashMap.values());
 
        // declaring the iterator
        Iterator<Integer> itr = listOfValues.iterator();
 
        // iterating through the list
        while (itr.hasNext()) {
 
            // comparing each value with the
            // one specified
            if (itr.next() == valueToBeChecked)
                return true;
        }
        return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // instantiating the class
        GFG ob = new GFG();
 
        // displaying and calling the
        // checkForValue() method
        System.out.println(ob.checkForValue(0));
    }
}

false