Hash Map 在java中的解释及示例

目录

• HashMap在java中的应用及示例
  • HashMap的内部结构
  • HashMap的性能
  • 同步HashMap
  • HashMap的构造函数
  • HashMap的时间复杂度
  • HashMap的方法
    • 1. void clear():用于从映射中删除所有映射。
    • 2. boolean containsKey(key_element)查询是否存在指定键的映射
    • 3. boolean containsValue(Object value):用于删除映射中任何特定键的值
    • 4. Object clone():它用于返回上述散列映射的浅拷贝
    • 5. boolean isEmpty():用于返回散列映射的集合视图
    • 6. Set entrySet():用于返回散列映射的Set视图
    • 7. Object get(Object key):用于检索或获取由特定键映射的值
    • 8. Set ketSet():它用于返回键的集合视图
    • 9. int size():它用于返回映射的大小
    • 10. Object put(Object key,Object value):用于将键值对的特定映射插入到映射中。
    • 11. putAll(Map M):它用于将一个映射中的所有元素复制到另一个映射中。
    • 12. Object remove(Object key):它用于删除映射中任何特定键的值。
    • 13. Collection values():它用于返回HashMap中值的集合视图。
      • 参考文献：

---

HashMap在java中的应用及示例

HashMap自1.2起就是java集合的一部分，它提供了java基本的map映射接口实现。通过将数据储存在(Key, Value)也就是键值对中。想要得到值就必须知道对应的键。之所以用 HashMap 命名是因为它使用了一个叫做 Hashing 的技术，Hashing 是一种可以将长字符串转换成短字符串并且表示的字符串相同。段字符串的好处是更快的标记和索引。HashSet同样偶尔使用HashMap，偶尔也会使用链表来储存键值对。

几个HashMap的重要属性：

• HashMap是java.util包的一部分
• HashMap集成子抽象类AbstractMap，并且AbstractMap也提供一个不万丈的Map接口实现。
• 它同样实现了可克隆和可序列化接口，K和V在之前的描述中分别代表Key和Value
• HashMap不允许有重复的Keys但是允许有重复的Values，即一个单独的key不能包含多个value，但不止一个key可以包含一个同样的value。
• HashMap允许唯一空Key但允许多个空Values
• 这个类不保证映射的顺序，它不能保证顺序一直保持不变，它和HashTable大致相似，但是不同步。

HashMap的内部结构

HashMap的内在包含了一个节点数组，其中一个节点可以表示成一个包含四个领域的类。

1. int hash
2. K key
3. V value
4. Node<K,V> next

Node包含了它自身对象的引用，所以这是一个链表。

HashMap：

HashMap的性能

1. 初始容量(Initial Capacity)
2. 负荷系数(Load Factor)
   • \(负荷系数 = \cfrac{表中存储的元素的数量}{哈希表的大小}\)
   • 示例：如果内部容量为16，负载系数为0.75，那么当表中有12个元素时，bucket的数量将自动增加。

容量即容器的承载量，一旦HashMap被实例化即有了初始容量。负荷系数使用来测量何时重新散列需要停止。重新散列是用来提升容量的步骤。在HashMap中容量是乘以2。负荷系数同样是测量那些部分在重新散列之前允许被填入。当HashMap中的条目数增加了当前容量和负载因子的乘积时，就会增加容量，这时就进行了重新散列。如果初始容量持续增高那么重新散列用不会停止，但是通过不断的增高初始容量它增加了迭代的时间复杂度，所以他应该谨慎选择来提升他的性能，当设置初始容量时应该将预计的values考虑在内。通常情况下负荷系数设置为0.75，它较好地平衡了时间和空间花费。负荷系数的value在0-1之间

同步HashMap

HashMap是非同步的也就是说多线程可以同时访问。如果多线程同是访问这个类而且至少有一个线程改变他的结构那么就有必要让他在外部同步。它是通过同步一些封装了映射的对象来完成的。如果不存在这样的对象，则可以将其封装在Collections.synchronizedMap()中，以使HashMap同步，并避免意外的非同步访问。

示例如下：

Map m = Collections.synchronizedMap(new HashMap(...));Map

现在Map m是同步的了

如果在创建迭代器之后进行任何结构修改(除了通过迭代器的remove方法之外的任何方式)，该类的迭代器都是快速失效的。在迭代器失败时，它将抛出ConcurrentModificationException。

HashMap的构造函数

HashMap提供了4个构造函数，每个的访问修饰符都是公共的:

1. HashMap():它是创建HashMap实例的默认构造函数，初始容量为16，负载系数为0.75。
2. HashMap(int初始容量):它创建一个HashMap实例，该实例具有指定的初始容量和负载因子0.75。
3. HashMap(int初始容量，float loadFactor):它创建一个HashMap实例，该实例具有指定的初始容量和指定的负载因子。
4. HashMap(Map Map):它使用与指定映射相同的映射创建HashMap实例。

Example：

    // Java program to illustrate
    // Java.util.HashMap 
    import java.util.HashMap;
    import java.util.Map; 
    public class GFG {
        public static void main(String[] args)
        { 
        HashMap<String, Integer> map
            = new HashMap<>(); 
        print(map);
        map.put("vishal", 10);
        map.put("sachin", 30);
        map.put("vaibhav", 20); 
        System.out.println("Size of map is:-"+ map.size()); 
        print(map);
        if (map.containsKey("vishal")) {
            Integer a = map.get("vishal");
            System.out.println("value for key"+ " \"vishal\" is:- "+ a);
        } 
        map.clear();
        print(map);
    } 
    public static void print(Map<String, Integer> map)
    {
        if (map.isEmpty()) {
            System.out.println("map is empty");
        } 
        else {
            System.out.println(map);
        }
    }
}

输出:

map is empty
Size of map is:- 3
{vaibhav=20, vishal=10, sachin=30}
value for key "vishal" is:- 10
map is empty

HashMap的时间复杂度

HashMap为基本操作提供了恒定的时间复杂度，如果正确编写了散列函数，并且正确地将元素分散到各个buckets中，则使用get和put。遍历所有的HashMap取决于HashMap的容量和许多键-值对。通常来说，它与容量+大小成正比。容量是HashMap中的buckets。所以一开始在HashMap中保留大量bucket不友好。

HashMap的方法

1. void clear():用于从映射中删除所有映射。

• 语法 Hash_Map.clear()
• 参数：无参数
• 返回值: 无返回值
• 示例如下：

 //将字符串映射成为整数键
 // Java code to illustrate the clear() method
 import java.util.*; 
 public class Hash_Map_Demo {
     public static void main(String[] args)
     { 
         // Creating an empty HashMap
         HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
         // Mapping string values to int keys
         hash_map.put(10, "pomelos");
         hash_map.put(15, "4");
         hash_map.put(20, "pomelos");
         hash_map.put(25, "Welcomes");
         hash_map.put(30, "You"); 
         // Displaying the HashMap
         System.out.println("Initial Mappings are: " + hash_map); 
         // Clearing the hash map using clear()
         hash_map.clear(); 
         // Displaying the final HashMap
         System.out.println("Finally the maps look like this: " + hash_map);
       }
   }

输出:

Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
Finally the maps look like this: {}

//将整数映射成为字符串
// Java code to illustrate the clear() method
import java.util.*; 
public class Hash_Map_Demo {
    public static void main(String[] args)
    { 
        // Creating an empty HashMap
        HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
        // Mapping int values to string keys
        hash_map.put("pomelos", 10);
        hash_map.put("4", 15);
        hash_map.put("pomelos", 20);
        hash_map.put("Welcomes", 25);
        hash_map.put("You", 30); 
        // Displaying the HashMap
        System.out.println("Initial Mappings are: " + hash_map); 
        // Clearing the hash map using clear()
        hash_map.clear(); 
        // Displaying the final HashMap
        System.out.println("Finally the maps look like this: " + hash_map);
    }
}

输出：

Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
Finally the maps look like this: {}

2. boolean containsKey(key_element)查询是否存在指定键的映射

• 语法 Hash_Map.containsKey(key_element)
• 参数： 只有key_element参数指向在映射中想要查询的映射元素。
• 返回值：返回值只有ture和false
• 示例如下：

 //将字符串映射为整数
 // Java code to illustrate the containsKey() method
 import java.util.*; 
 public class Hash_Map_Demo {
     public static void main(String[] args)
     { 
     // Creating an empty HashMap
     HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
     // Mapping string values to int keys
     hash_map.put(10, "pomelos");
     hash_map.put(15, "4");
     hash_map.put(20, "pomelos");
     hash_map.put(25, "Welcomes");
     hash_map.put(30, "You"); 
     // Displaying the HashMap
     System.out.println("Initial Mappings are: " + hash_map); 
     // Checking for the key_element '20'
     System.out.println("Is the key '20' present? " +
     hash_map.containsKey(20)); 
     // Checking for the key_element '5'
     System.out.println("Is the key '5' present? " +
     hash_map.containsKey(5));
     }
 }

输出：

Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
 Is the key '20' present? true
 Is the key '5' present? false

//将整数映射成为字符串
// Java code to illustrate the containsKey() method
 import java.util.*; 
 public class Hash_Map_Demo {
     public static void main(String[] args)
     { 
     // Creating an empty HashMap
     HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
     // Mapping int values to string keys
     hash_map.put("pomelos", 10);
     hash_map.put("4", 15);
     hash_map.put("pomelos", 20);
     hash_map.put("Welcomes", 25);
     hash_map.put("You", 30); 
     // Displaying the HashMap
     System.out.println("Initial Mappings are: " + hash_map); 
     // Checking for the key_element 'Welcomes'
     System.out.println("Is the key 'Welcomes' present? " +
     hash_map.containsKey("Welcomes")); 
     // Checking for the key_element 'World'
     System.out.println("Is the key 'World' present? " +
     hash_map.containsKey("World"));
     }
 }

输出:

 Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
 Is the key 'Welcomes' present? true
 Is the key 'World' present? false

3. boolean containsValue(Object value):用于删除映射中任何特定键的值

• 语法：Hash_Map.containsValue(Object Value)
• 参数： 该方法仅接受对象类型的一个参数值，并引用其映射应该由映射内的任何键进行检查的值。
• 返回值：如果检测到值的映射，则该方法返回布尔值true，其余情况均为false。
• 时间复杂度：O(n)
• 示例如下：

// 将字符串映射为整数
// Java code to illustrate the containsValue() method
 import java.util.*; 
 public class Hash_Map_Demo {
     public static void main(String[] args)
     { 
     // Creating an empty HashMap
     HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
     // Mapping string values to int keys
     hash_map.put(10, "pomelos");
     hash_map.put(15, "4");
     hash_map.put(20, "pomelos");
     hash_map.put(25, "Welcomes");
     hash_map.put(30, "You"); 
     // Displaying the HashMap
     System.out.println("Initial Mappings are: " + hash_map); 
     // Checking for the Value 'pomelos'
     System.out.println("Is the value 'pomelos' present? " +
     hash_map.containsValue("pomelos")); 
     // Checking for the Value 'World'
     System.out.println("Is the value 'World' present? " +
     hash_map.containsValue("World"));
     }
 }

输出:

Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
 Is the value 'pomelos' present? true
 Is the value 'World' present? false

// 经整数映射为字符串
// Java code to illustrate the containsValue() method
 import java.util.*; 
 public class Hash_Map_Demo {
     public static void main(String[] args)
     { 
     // Creating an empty HashMap
     HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
     // Mapping int values to string keys
     hash_map.put("pomelos", 10);
     hash_map.put("4", 15);
     hash_map.put("pomelos", 20);
     hash_map.put("Welcomes", 25);
     hash_map.put("You", 30); 
     // Displaying the HashMap
     System.out.println("Initial Mappings are: " + hash_map); 
     // Checking for the Value '10'
     System.out.println("Is the value '10' present? " +
     hash_map.containsValue(10)); 
     // Checking for the Value '30'
     System.out.println("Is the value '30' present? " +
     hash_map.containsValue(30)); 
     // Checking for the Value '40'
     System.out.println("Is the value '40' present? " +
     hash_map.containsValue(40));
     }
 }

输出：

 Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
 Is the value '10' present? false
 Is the value '30' present? true
 Is the value '40' present? false

4. Object clone():它用于返回上述散列映射的浅拷贝

• 语法 Hash_Map.clone()
• 参数: 无参数
• 返回值：该方法只返回HashMap的一个副本
• 示例如下：

  // 将字符串映射为数字
  // Java code to illustrate the clone() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      // Mapping string values to int keys
      hash_map.put(10, "pomelos");
      hash_map.put(15, "4");
      hash_map.put(20, "pomelos");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You"); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Displaying the cloned HashMap using clone()
      System.out.println("The cloned map look like this: " + hash_map.clone());
      }
  }

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
  The cloned map look like this: {25=Welcomes, 10=pomelos, 20=pomelos, 30=You, 15=4}

  // 将整数映射为字符串
  // Java code to illustrate the clone() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
      // Mapping int values to string keys
      hash_map.put("pomelos", 10);
      hash_map.put("4", 15);
      hash_map.put("pomelos", 20);
      hash_map.put("Welcomes", 25);
      hash_map.put("You", 30); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Displaying the cloned HashMap using clone()
      System.out.println("The cloned map look like this: " + hash_map.clone());
      }
  }

输出：

  Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
  The cloned map look like this: {pomelos=20, 4=15, You=30, Welcomes=25}

5. boolean isEmpty():用于返回散列映射的集合视图

• 语法 Hash_Map.isEmpty()
• 参数： 无参数
• 返回值： 如果映射为空或不包含任何映射对，则该方法返回布尔值true，反之则为false。
• 示例如下：

  // 将整数映射成为字符串
  // Java code to illustrate the isEmpty() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
      // Mapping int values to string keys
      hash_map.put("pomelos", 10);
      hash_map.put("4", 15);
      hash_map.put("pomelos", 20);
      hash_map.put("Welcomes", 25);
      hash_map.put("You", 30); 
      // Displaying the HashMap
      System.out.println("The Mappings are: " + hash_map); 
      // Checking for the emptiness of Map
      System.out.println("Is the map empty? " + hash_map.isEmpty());
      }
  }

输出：

  The Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
  Is the map empty? false

  // 对于空hashMap
  // Java code to illustrate the isEmpty() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
      // Displaying the HashMap
      System.out.println("The Mappings are: " + hash_map); 
      // Checking for the emptiness of Map
      System.out.println("Is the map empty? " + hash_map.isEmpty());
      }
  }

输出:

  The Mappings are: {}
  Is the map empty? true

6. Set entrySet():用于返回散列映射的Set视图

• 语法 hash_map.entrySet()
• 参数：无参数
• 返回值： 该方法返回与散列映射具有相同元素的集合。
• 示例：

  // 字符串映射成整数
  // Java code to illustrate the entrySet() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      // Mapping string values to int keys
      hash_map.put(10, "pomelos");
      hash_map.put(15, "4");
      hash_map.put(20, "pomelos");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You"); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Using entrySet() to get the set view
      System.out.println("The set is: " + hash_map.entrySet());
      }
  }

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
  The set is: [20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4]

// 讲整数映射成为字符串
// Java code to illustrate the entrySet() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
      // Mapping int values to string keys
      hash_map.put("pomelos", 10);
      hash_map.put("4", 15);
      hash_map.put("pomelos", 20);
      hash_map.put("Welcomes", 25);
      hash_map.put("You", 30); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Using entrySet() to get the set view
      System.out.println("The set is: " + hash_map.entrySet());
      }
  }

输出：

  Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
  The set is: [4=15, pomelos=20, You=30, Welcomes=25]

7. Object get(Object key):用于检索或获取由特定键映射的值

• 语法 hash_map.keySet()
• 参数： 无需参数
• 返回值： 该方法返回一个具有散列映射键的集合。
• 示例如下：

// 将字符串映射为整数值
// Java code to illustrate the keySet() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      // Mapping string values to int keys
      hash_map.put(10, "pomelos");
      hash_map.put(15, "4");
      hash_map.put(20, "pomelos");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You"); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Using keySet() to get the set view of keys
      System.out.println("The set is: " + hash_map.keySet());
      }
  }

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
  The set is: [20, 25, 10, 30, 15]

// 将整数映射成为字符串
// Java code to illustrate the keySet() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
      // Mapping int values to string keys
      hash_map.put("pomelos", 10);
      hash_map.put("4", 15);
      hash_map.put("pomelos", 20);
      hash_map.put("Welcomes", 25);
      hash_map.put("You", 30); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Using keySet() to get the set view of keys
      System.out.println("The set is: " + hash_map.keySet());
      }
  }

输出：

  Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
  The set is: [4, pomelos, You, Welcomes]

8. Set ketSet():它用于返回键的集合视图

* 语法 hash_map.keySet()
* 参数： 无参数
* 返回值：该方法返回一个具有散列映射键的集合。
* 示例如下：

// 将字符串映射为整数
// Java code to illustrate the keySet() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      // Mapping string values to int keys
      hash_map.put(10, "pomelos");
      hash_map.put(15, "4");
      hash_map.put(20, "pomelos");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You"); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Using keySet() to get the set view of keys
      System.out.println("The set is: " + hash_map.keySet());
  }
}

输出：

    Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
    The set is: [20, 25, 10, 30, 15]

//将整数映射为字符串
// Java code to illustrate the keySet() method
import java.util.*; 
public class Hash_Map_Demo {
    public static void main(String[] args)
    { 
        // Creating an empty HashMap
        HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
        // Mapping int values to string keys
        hash_map.put("pomelos", 10);
        hash_map.put("4", 15);
        hash_map.put("pomelos", 20);
        hash_map.put("Welcomes", 25);
        hash_map.put("You", 30); 
        // Displaying the HashMap
        System.out.println("Initial Mappings are: " + hash_map); 
        // Using keySet() to get the set view of keys
        System.out.println("The set is: " + hash_map.keySet());
    }
}

输出：

    Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
    The set is: [4, pomelos, You, Welcomes]

9. int size():它用于返回映射的大小

* 语法： Hash_Map.size()
* 参数: 无需参数
* 返回值： 该方法返回映射的大小，这也表示映射中存在的键值对的数量。
* 示例如下

//将字符串映射成为整数
// Java code to illustrate the size() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      // Mapping string values to int keys
      hash_map.put(10, "pomelos");
      hash_map.put(15, "4");
      hash_map.put(20, "pomelos");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You"); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Displaying the size of the map
      System.out.println("The size of the map is " + hash_map.size());
      }
  }

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
  The size of the map is 5

  // 将整数映射成为字符串
  // Java code to illustrate the size() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
      // Mapping int values to string keys
      hash_map.put("pomelos", 10);
      hash_map.put("4", 15);
      hash_map.put("pomelos", 20);
      hash_map.put("Welcomes", 25);
      hash_map.put("You", 30); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Displaying the size of the map
      System.out.println("The size of the map is " + hash_map.size());
      }
  }

输出：

  Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
  The size of the map is 4

10. Object put(Object key,Object value):用于将键值对的特定映射插入到映射中。

• 语法 Hash_Map.put(key, value)
• 参数： 该方法有两个参数，都是HashMap的对象类型。
  • key: This refers to the key element that needs to be inserted into the Map for mapping.
  • value: This refers to the value that the above key would map into.
• 返回值： 如果传递了现有的键，则返回以前的值。如果传递了一个新对，则返回NULL。
• 示例如下：

// 当传递一个存在key
// Java code to illustrate the put() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      // Mapping string values to int keys
      hash_map.put(10, "pomelos");
      hash_map.put(15, "4");
      hash_map.put(20, "pomelos");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You"); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Inserting existing key along with new value
      String returned_value = (String)hash_map.put(20, "All"); 
      // Verifying the returned value
      System.out.println("Returned value is: " + returned_value); 
      // Displayin the new map
      System.out.println("New map is: " + hash_map);
      }
  }

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
  Returned value is: pomelos
  New map is: {20=All, 25=Welcomes, 10=pomelos, 30=You, 15=4}

// 当传递一个新值
// Java code to illustrate the put() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      // Mapping string values to int keys
      hash_map.put(10, "pomelos");
      hash_map.put(15, "4");
      hash_map.put(20, "pomelos");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You"); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Inserting existing key along with new value
      String returned_value = (String)hash_map.put(50, "All"); 
      // Verifying the returned value
      System.out.println("Returned value is: " + returned_value); 
      // Displayin the new map
      System.out.println("New map is: " + hash_map);
      }
  }

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
  Returned value is: null
  New map is: {50=All, 20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}

11. putAll(Map M):它用于将一个映射中的所有元素复制到另一个映射中。

• 语法 new_hash_map.putAll(exist_hash_map)
• 参数：该方法接受一个参数exist_hash_map，该参数引用我们想要复制的现有映射。
• 返回值: 无返回值
• 异常:如果我们想要复制的映射是NULL，这个方法会抛出 NullPointerException。
• 示例如下：

      // 将字符串映射为整数
      // Java code to illustrate the putAll() method
      import java.util.*; 
      public class Hash_Map_Demo {
      public static void main(String[] args) { 
      // Creating an empty HashMap
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      // Mapping string values to int keys
      hash_map.put(10, "pomelos");
      hash_map.put(15, "4");
      hash_map.put(20, "pomelos");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You"); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Creating a new hash map and copying
      HashMap<Integer, String> new_hash_map = new HashMap<Integer, String>();
      new_hash_map.putAll(hash_map); 
      // Displaying the final HashMap
      System.out.println("The new map looks like this: " + new_hash_map);
      }
  }

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
  The new map looks like this: {25=Welcomes, 10=pomelos, 20=pomelos, 30=You, 15=4}

// 将整数映射成为字符串
// Java code to illustrate the putAll() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
      // Creating an empty HashMap
      HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
      // Mapping int values to string keys
      hash_map.put("pomelos", 10);
      hash_map.put("4", 15);
      hash_map.put("pomelos", 20);
      hash_map.put("Welcomes", 25);
      hash_map.put("You", 30); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Creating a new hash map and copying
      HashMap<String, Integer> new_hash_map = new HashMap<String, Integer>();
      new_hash_map.putAll(hash_map); 
      // Displaying the final HashMap
      System.out.println("The new map looks like this: " + new_hash_map);
      }
  }

输出：

  Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
  The new map looks like this: {pomelos=20, 4=15, You=30, Welcomes=25}

12. Object remove(Object key):它用于删除映射中任何特定键的值。

• 语法 Hash_Map.remove(Object key)
• 参数： 该方法采用一个要从映射中删除其映射的参数键。
• 返回值：如果键存在，该方法将返回先前映射到指定键的值，否则将返回NULL。
• 示例如下：

  // 当传递一个已存在key
  // Java code to illustrate the remove() method
      import java.util.*; 
      public class Hash_Map_Demo {
      public static void main(String[] args) { 
      // Creating an empty HashMap
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      // Mapping string values to int keys
      hash_map.put(10, "pomelos");
      hash_map.put(15, "4");
      hash_map.put(20, "pomelos");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You"); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map);  
      // Removing the existing key mapping
      String returned_value = (String)hash_map.remove(20); 
      // Verifying the returned value
      System.out.println("Returned value is: "+ returned_value); 
      // Displayin the new map
      System.out.println("New map is: "+ hash_map);
      }
  }

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
  Returned value is: pomelos
  New map is: {25=Welcomes, 10=pomelos, 30=You, 15=4}

// 当传递一个新key
// Java code to illustrate the remove() method
  import java.util.*; 
  public class Hash_Map_Demo {
  public static void main(String[] args) { 
    // Creating an empty HashMap
    HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
    // Mapping string values to int keys
    hash_map.put(10, "pomelos");
    hash_map.put(15, "4");
    hash_map.put(20, "pomelos");
    hash_map.put(25, "Welcomes");
    hash_map.put(30, "You"); 
    // Displaying the HashMap
    System.out.println("Initial Mappings are: " + hash_map);  
    // Removing the new key mapping
    String returned_value = (String)hash_map.remove(50); 
    // Verifying the returned value
    System.out.println("Returned value is: "+ returned_value); 
    // Displayin the new map
    System.out.println("New map is: "+ hash_map);
 }
}

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 3`0=You, 15=4}
  Returned value is: null
  New map is: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}

13. Collection values():它用于返回HashMap中值的集合视图。

• 语法 Hash_Map.values()
• 参数：无参数
• 返回值：该方法用于返回包含映射的所有值的集合视图。
• 示例如下：

  // 将字符串映射为整数
  // Java code to illustrate the values() method
  import java.util.*; 
  public class Hash_Map_Demo {
      public static void main(String[] args)
      { 
          // Creating an empty HashMap
          HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
          // Mapping string values to int keys
          hash_map.put(10, "pomelos");
          hash_map.put(15, "4");
          hash_map.put(20, "pomelos");
          hash_map.put(25, "Welcomes");
          hash_map.put(30, "You"); 
          // Displaying the HashMap
          System.out.println("Initial Mappings are: " + hash_map); 
          // Using values() to get the set view of values
          System.out.println("The collection is: " + hash_map.values());
      }
  }

输出：

  Initial Mappings are: {20=pomelos, 25=Welcomes, 10=pomelos, 30=You, 15=4}
  The collection is: [pomelos, Welcomes, pomelos, You, 4]

// 将整数映射成字符串
// Java code to illustrate the values() method
import java.util.*; 
public class Hash_Map_Demo {
  public static void main(String[] args)
  { 
      // Creating an empty HashMap
      HashMap<String, Integer> hash_map = new HashMap<String, Integer>(); 
      // Mapping int values to string keys
      hash_map.put("pomelos", 10);
      hash_map.put("4", 15);
      hash_map.put("pomelos", 20);
      hash_map.put("Welcomes", 25);
      hash_map.put("You", 30); 
      // Displaying the HashMap
      System.out.println("Initial Mappings are: " + hash_map); 
      // Using values() to get the set view of values
      System.out.println("The collection is: " + hash_map.values());
  }
}

输出：

  Initial Mappings are: {4=15, pomelos=20, You=30, Welcomes=25}
  The collection is: [15, 20, 30, 25]

参考文献：

https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html

https://www.geeksforgeeks.org/hashset-in-java/