Diferencia entre el método value() y entrySet() en el mapa de Java

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 .

Método 1: 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.

Ejemplo:

// Java program demonstrating use of values() method
 
// Importing all input output classes
import java.io.*;
// Importing HashMap, Iterator, Map and Stream classes
// from the 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 a Map object
        // Declaring object of String and integer type
        Map<Integer, String> map = new HashMap<>();
 
        // Now, adding the elements to the object created
        // Elements here are key- \value pairs
 
        // Custom input objects
        map.put(1, "Geeks");
        map.put(2, "For");
        map.put(3, "Geeks");
 
        // Showcasing different ways to illustrate
        // values() method
 
        // Way 1 - Using iterator
        // Iterating over the object elements of the
        // showcasing the values() method using iterator
 
        // Creating an object of Integer type
        Iterator<String> itr = map.values().iterator();
 
        // Condition check which holds true till
        // there is single elementusing hasNext() method
        while (itr.hasNext()) {
 
            // Traversing across the elements
            // using next() method
 
            // Printing the elements in the object
            System.out.print(itr.next() + " ");
        }
 
        // New line
        System.out.println();
 
        // Way 2 - Using loops
        // Iterating over the elements using for-each loop
        // to showacase value() method
        for (String key : map.values()) {
 
            // Printing all the element in object
            // key-value pairs
            System.out.println(key);
        }
 
        // New line
        System.out.println();
 
        // Iterating over the values() method by
        // converting the Map to the string
        System.out.println(map.values().toString());
    }
}

Geeks For Geeks 
Geeks
For
Geeks

[Geeks, For, Geeks]

Método 2: método entrySet()

El método java.util.HashMap.entrySet() en Java se usa para crear un conjunto de los mismos elementos contenidos en el mapa hash. Básicamente, devuelve una vista establecida del mapa hash, o podemos crear un nuevo conjunto y almacenar los elementos del mapa en ellos.

Sintaxis: 

hash_map.entrySet()

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

Valor devuelto: el método devuelve un conjunto que tiene los mismos elementos que el mapa hash.

Implementación:

Ejemplo 

// Java program demonstrating use of entrySet() method
 
//  Importing Map,Stream, hashMap and Iterator classes
// from the 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 an object of Map class
        // Declaring object of Integer and String type
        Map<Integer, String> map = new HashMap<>();
 
        // Now, adding the elements to the object
        // Here elements are key-value pairs to map
 
        // Custom input elements
        map.put(1, "Geeks");
        map.put(2, "For");
        map.put(3, "Geeks");
 
        // Now, proposing different cases in which we will
        // be iterating over the elements using entrySet()
 
        // Case 1
        // Iterating the key value pairs
        // using for each loop
        for (Map.Entry<Integer, String> entry :
             map.entrySet()) {
 
            // Corresponding key
            Integer key = (Integer)entry.getKey();
 
            // Corresponding pair
            String value = entry.getValue();
 
            // Printing all the corresponding key-value
            // pairs
            System.out.println(key + "=" + value);
        }
 
        // Case 2
        // Iterating the key-value pairs
        // using iterator
        Iterator<Map.Entry<Integer, String> > itr
            = map.entrySet().iterator();
 
        // Condition check using hasNext() method holding
        // true till there is single entry remaining
        while (itr.hasNext()) {
 
            // Go on printing key-value pairs
            System.out.println(itr.next());
        }
 
        // Case 3
        // Iterating and printing the key-value pairs
        // using Stream.of() method
 
        // Printing alongside by using scope resolution
        // operator
        Stream.of(map.entrySet().toArray())
            .forEach(System.out::println);
    }
}

1=Geeks
2=For
3=Geeks
1=Geeks
2=For
3=Geeks
1=Geeks
2=For
3=Geeks

Ahora veamos las diferencias entre el método de valores() y el método de entrada()