碼上快樂

相關內容    簡體    繁體

Hash Map 詳細解釋及示例

本文轉載自   查看原文   2019-11-29 19:01   252    java web

目錄

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大致相似，但是不同步。

alt image

HashMap的內部結構

HashMap的內在包含了一個節點數組，其中一個節點可以表示成一個包含四個領域的類。

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

Node包含了它自身對象的引用，所以這是一個鏈表。
HashMap：
alt image

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/


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 bat腳本彈出消息示例(msg命令詳細解釋) Map 的解釋 hash與map的區別聯系應用 hash_map的簡潔實現 STL—map、hash_map、unordered_map map，hash_map和unordered_map 實現比較 位非運算(~) 詳細解釋 es6的map()方法解釋 c++之STL模板，hash_set與hash_map STL map 詳細用法
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM