Diferencia entre el método keySet() vs value() en Java Map

Map Interface está presente en el paquete Java.util, que proporciona principalmente tres métodos KeySet(), entrySet() y values(). Estos métodos se utilizan para recuperar las claves del mapa, los pares clave-valor del mapa y los valores del mapa, respectivamente. Dado que estos métodos son parte de la interfaz del mapa, podemos usar estos métodos con todas las clases que implementan la interfaz del mapa, como TreeMap , HashMap y LinkedHashMap .

Para descubrir las diferencias, primero analicémoslas individualmente conceptualmente, seguido de la implementación para descubrir las principales diferencias entre ellas. 

Método 1: método keySet() 

Este método se utiliza para devolver una vista de conjunto de las claves contenidas en este mapa. El conjunto está respaldado por el mapa, por lo que los cambios en el mapa se reflejan en el conjunto y viceversa.

Sintaxis:

Set keySet()

Parámetros: Este método no tiene argumento.

Devoluciones: este método devuelve un conjunto que contiene claves del mapa especificado.

Implementación:

Ejemplo

// Java program demonstrating use of keySet() method
 
// Importing HashMap, Iterator, MAp and Stream classes
// from java.util package
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.stream.Stream;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating object of Map Class
        // Declaring object of Interfere and string type
        Map<Integer, String> map = new HashMap<>();
 
        // Adding the elements to the objects
        // Elements here are key-value pairs in the map
 
        // Custom input entries
        map.put(1, "Geeks");
        map.put(2, "For");
        map.put(3, "Geeks");
 
        // Now, different ways of iteration are illustrated
        // to showcase keySet() method
 
        // Way 1
        // Iterating the keySet() using iterator
 
        // Creating an object of Integer type
        Iterator<Integer> itr = map.keySet().iterator();
 
        // Condition check where hasNext() method holds true
        // till there is single element remaining in the List
        while (itr.hasNext()) {
 
            // Print all the elements(key-value pairs)
            System.out.print(itr.next() + " ");
        }
 
        // New line
        System.out.println();
 
        // Way 2
        // Iterating the keySet()
        // using for loop
        for (Integer key : map.keySet()) {
 
            // Print all the key-value pairs
            System.out.print(key + " ");
        }
 
        // New line
        System.out.println();
 
        // Way 3
        // Iterating over the keySet() by
        // converting the map to the string
        // using the toString() method
        System.out.println(map.keySet().toString());
    }
}

1 2 3 
1 2 3 
[1, 2, 3]

Método 2: método de valores() 

El método java.util.HashMap.values() de la clase HashMap en Java se usa para crear una colección a partir de los valores del mapa. Básicamente, devuelve una vista de colección de los valores en HashMap.

Sintaxis: 

Hash_Map.values()

Parámetros: El método no acepta ningún parámetro.

Valor devuelto: el método se utiliza para devolver una vista de colección que contiene todos los valores del mapa.

Implementación: a continuación se muestra el programa Java usando el método  de valores()

Ejemplo 

// Java program demonstrating use of values() method
 
// Importing several classes from
// java.util package
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.stream.Stream;
 
// Class
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Making map of Integer keys and String values
        Map<Integer, String> map = new HashMap<>();
 
        // Adding the elements to the above object
        // Declaring object of Integer and String type
 
        // Elements here are key-value pairs
        // Custom input entries
        map.put(1, "Geeks");
        map.put(2, "For");
        map.put(3, "Geeks");
 
        // values() method implemented by
        // demonstrating different ways of traversal
 
        // Way 1
        // Iterating the values() method
        // using iterator
        Iterator itr = map.values().iterator();
 
        // Condition check using hasNet() method which
        // holds true till there is single element remaining
        while (itr.hasNext()) {
            System.out.print(itr.next() + " ");
        }
        System.out.println();
 
        // Way 2
        // Iterating the values() method
        // using for each loop
        for (String key : map.values()) {
            System.out.print(key + " ");
        }
        System.out.println();
 
        // Way 3
        // iterating over the values() method
        // by converting the map to the string
        // using the toString() method
        System.out.println(map.values().toString());
    }
}

Geeks For Geeks 
Geeks For Geeks 
[Geeks, For, Geeks]

Ahora, finalmente, llegamos a la conclusión, veamos las diferencias entre el método keySet() y el método de valores() de la siguiente manera: