day04 【Map】

阿新 • • 發佈：2019-01-06

day04 【Map】

主要內容

Map集合

教學目標

能夠說出Map集合特點
使用Map集合新增方法儲存資料
使用”鍵找值”的方式遍歷Map集合
使用”鍵值對”的方式遍歷Map集合
能夠使用HashMap儲存自定義鍵值對的資料
能夠使用HashMap編寫鬥地主洗牌發牌案例

第一章 Map集合

1.1 概述

現實生活中，我們常會看到這樣的一種資料的集合體：IP地址與主機名，身份證號與個人，系統使用者名稱與系統使用者物件等，這種一一對應的關係，就叫做對映。Java提供了專門的集合類用來存放這種物件關係的物件，即java.util.Map介面。

在Map集合中儲存的資料為一組資料，其中：一個數據為key，另外一個數據為value。而key和value具備對應的關係，在集合中它們屬於一組（一對）資料。而每個key只能對應唯一的一個value值並且所有的key不能重複。但是其中的value值是可以重複的。

Collection中的集合，元素是孤立存在的（理解為單身），向集合中儲存元素採用一個個元素的方式儲存。
Map中的集合，元素是成對存在的(理解為夫妻)。每個元素由鍵與值兩部分組成，通過鍵可以找對所對應的值。
Collection中的集合稱為單列集合，Map中的集合稱為雙列集合。
需要注意的是，Map中的集合不能包含重複的鍵，值可以重複；每個鍵只能對應一個值。

1.2 Map常用子類

通過檢視Map介面描述，看到Map有多個子類，這裡我們主要講解常用的兩個集合:

HashMap集合

LinkedHashMap集合。

HashMap<K,V>：儲存資料採用的雜湊表結構，元素的存取順序不能保證一致。由於要保證鍵的唯一、不重複，因此需要重寫鍵的hashCode()方法、equals()方法。
LinkedHashMap<K,V>：儲存資料採用的雜湊表結構+連結串列結構。通過連結串列結構可以保證元素的存取順序一致；通過雜湊表結構可以保證的鍵的唯一、不重複，需要重寫鍵的hashCode()方法、equals()方法。

tips：Map介面中的集合都有兩個泛型變數<K,V>,在使用時，要為兩個泛型變數賦予資料型別。兩個泛型變數<K,V>的資料型別可以相同，也可以不同。

1.3 Map介面中的常用方法

Map介面中定義了很多方法，常用的如下：

public V put(K key, V value): 把指定的鍵與指定的值新增到Map集合中。如果鍵值存在則覆蓋。
public V remove(Object key): 把指定的鍵和對應的值在集合中刪除，返回被刪除元素的值。
public V get(Object key) 根據指定的鍵，在Map集合中獲取對應的值。

Map介面的方法演示

public class MapDemo {
    public static void main(String[] args) {
        //建立 map物件
        HashMap<String, String>  map = new HashMap<String, String>();

        //新增元素到集合
        map.put("黃曉明", "楊穎");
        map.put("文章", "馬伊琍");
        map.put("鄧超", "孫儷");
        System.out.println(map);

        //String remove(String key)
        System.out.println(map.remove("鄧超"));
        System.out.println(map);

        // 想要檢視 黃曉明的媳婦 是誰
        System.out.println(map.get("黃曉明"));
        System.out.println(map.get("鄧超"));    
    }
}

tips:

使用put方法時，若指定的鍵(key)在集合中沒有，則沒有這個鍵對應的值，返回null，並把指定的鍵值新增到集合中；

若指定的鍵(key)在集合中存在，則返回值為集合中鍵對應的值（該值為替換前的值），並把指定鍵所對應的值，替換成指定的新值。

1.4 Map集合遍歷鍵找值方式

在Map集合體系中並沒有給我們提供迭代遍歷的方式，也就是說在Map集合中，我們無法使用Collection集合體系中的Iterator迭代器對Map集合進行遍歷，那Map集合體系如何完成遍歷呢？在Map集合體系中給我們提供了下列方法：

public Set keySet(): 獲取Map集合中所有的鍵，儲存到Set集合中。

鍵找值方式：即通過元素中的鍵，獲取鍵所對應的值

分析步驟：

獲取Map中所有的鍵，由於鍵是唯一的，所以返回一個Set集合儲存所有的鍵。方法提示:keyset()
遍歷鍵的Set集合，得到每一個鍵。
根據鍵，獲取鍵所對應的值。方法提示:get(K key)

程式碼演示：

public class MapDemo01 {
    public static void main(String[] args) {
        //建立Map集合物件 
        HashMap<String, String> map = new HashMap<String,String>();
        //新增元素到集合 
        map.put("胡歌", "霍建華");
        map.put("郭德綱", "于謙");
        map.put("薛之謙", "大張偉");

        //獲取所有的鍵  獲取鍵集
        Set<String> keys = map.keySet();
        // 遍歷鍵集 得到 每一個鍵
        for (String key : keys) {
          	//key  就是鍵
            //獲取對應值
            String value = map.get(key);
            System.out.println(key+"的CP是："+value);
        }  
    }
}

1.5 Entry鍵值對物件

public Set<Map.Entry<K,V>> entrySet(): 獲取集合中所有的鍵值對物件，儲存到Set集合中。

我們已經知道，Map中存放的是兩種物件，一種稱為key(鍵)，一種稱為value(值)，它們在在Map中是一一對應關係，這一對物件又稱做Map中的一個Entry(項)。Entry將鍵值對的對應關係封裝成了物件。即鍵值對物件，這樣我們在遍歷Map集合時，就可以從每一個鍵值對（Entry）物件中獲取對應的鍵與對應的值。

既然Entry表示了一對鍵和值，那麼也同樣提供了獲取對應鍵和對應值得方法：

public K getKey()：獲取Entry物件中的鍵。
public V getValue()：獲取Entry物件中的值。

在Map集合中也提供了獲取所有Entry物件的方法：

public Set<Map.Entry<K,V>> entrySet(): 獲取到Map集合中所有的鍵值對物件的集合(Set集合)。

1.6 Map集合遍歷鍵值對方式

鍵值對方式：即通過集合中每個鍵值對(Entry)物件，獲取鍵值對(Entry)物件中的鍵與值。

操作步驟與圖解：

獲取Map集合中，所有的鍵值對(Entry)物件，以Set集合形式返回。方法提示:entrySet()。
遍歷包含鍵值對(Entry)物件的Set集合，得到每一個鍵值對(Entry)物件。
通過鍵值對(Entry)物件，獲取Entry物件中的鍵與值。方法提示:getkey() getValue()

public class MapDemo02 {
public static void main(String[] args) {
// 建立Map集合物件
HashMap<String, String> map = new HashMap<String,String>();
// 新增元素到集合
map.put(“胡歌”, “霍建華”);
map.put(“郭德綱”, “于謙”);
map.put(“薛之謙”, “大張偉”);
```
     // 獲取 所有的 entry物件  entrySet
     Set<Entry<String,String>> entrySet = map.entrySet();

     // 遍歷得到每一個entry物件
     for ( Entry<String, String> entry : entrySet) {
        	// 解析 
         String key = entry.getKey();
         String value = entry.getValue();  
         System.out.println(key+"的CP是:"+value);
     }
 }
```
}

tips：Map集合不能直接使用迭代器或者foreach進行遍歷。但是轉成Set之後就可以使用了。

1.7 HashMap儲存自定義型別鍵值

練習：每位學生（姓名，年齡）都有自己的家庭住址。那麼，既然有對應關係，則將學生物件和家庭住址儲存到map集合中。學生作為鍵, 家庭住址作為值。

注意，學生姓名相同並且年齡相同視為同一名學生。

編寫學生類：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

編寫測試類：

public class HashMapTest {    
  public static void main(String[] args) {        
    //1,建立Hashmap集合物件。        
    Map<Student,String>map = new HashMap<Student,String>();        
    //2,新增元素。        
    map.put(newStudent("lisi",28), "上海");        
    map.put(newStudent("wangwu",22), "北京");        
    map.put(newStudent("zhaoliu",24), "成都");        
    map.put(newStudent("zhouqi",25), "廣州");        
    map.put(newStudent("wangwu",22), "南京");                
    //3,取出元素。鍵找值方式        
    Set<Student>keySet = map.keySet();        
    for(Student key: keySet){            
      Stringvalue = map.get(key);  
      System.out.println(key.toString()+"....."+value);   
    }    
  }
}

當給HashMap中存放自定義物件時，如果自定義物件作為key存在，這時要保證物件唯一，必須複寫物件的hashCode和equals方法(如果忘記，請回顧HashSet存放自定義物件)。
如果要保證map中存放的key和取出的順序一致，可以使用java.util.LinkedHashMap集合來存放。
另外在Map集合中還提供了一個靜態方法values()，它的作用是將Map集合中的所有value值儲存到一個Collection集合中，通過遍歷Collection集合就可以獲取到Map集合中的所有value值。

1.8 LinkedHashMap

我們知道HashMap保證成對元素唯一，並且查詢速度很快，可是成對元素存放進去是沒有順序的，那麼我們要保證有序，還要速度快怎麼辦呢？

在HashMap下面有一個子類LinkedHashMap，它是連結串列和雜湊表組合的一個數據儲存結構。在保證key值物件唯一的前提下，還能保證元素的存取順序。

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
        map.put("鄧超", "孫儷");
        map.put("李晨", "范冰冰");
        map.put("劉德華", "朱麗倩");
        Set<Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() + "  " + entry.getValue());
        }
    }
}

結果:

鄧超  孫儷
李晨  范冰冰
劉德華  朱麗倩

1.9 Map集合練習

需求：

計算一個字串中每個字元出現次數。

分析：

獲取一個字串物件
建立一個Map集合，鍵代表字元，值代表次數。
遍歷字串得到每個字元。
判斷Map中是否有該鍵。
如果沒有，第一次出現，儲存次數為1；如果有，則說明已經出現過，獲取到對應的值進行++，再次儲存。
列印最終結果

程式碼：

public class MapTest {
public static void main(String[] args) {
        //友情提示
        System.out.println("請錄入一個字串:");
        String line = new Scanner(System.in).nextLine();
        // 定義 每個字元出現次數的方法
        findChar(line);
    }
    public static void findChar(String line) {
        //1:建立一個集合 儲存  字元 以及其出現的次數
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        //2:遍歷字串
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            //判斷 該字元 是否在鍵集中
            if (!map.containsKey(c)) {//說明這個字元沒有出現過
                //那就是第一次
                map.put(c, 1);
            } else {
                //先獲取之前的次數
                Integer count = map.get(c);
                //count++;
                //再次存入  更新
                map.put(c, ++count);
            }
        }
        System.out.println(map);
    }
}

2.0 排序集合TreeMap瞭解

如果儲存到Map集合中的key值資料需要排序，則可以使用TreeMap集合。集合內部會自動完成key值物件的排序動作。如果想自定義排序方式，可以在建立集合物件時傳遞一個比價器物件。

TreeMap()：使用自然順序對key值進行排序。

TreeMap(Comparator comparator)：建立物件時，傳遞比較器物件。按比較器的比較方式排序。

程式碼演示

public class Demo {
    public static void main(String[] args) {
        // 建立集合物件，key值按照自然順序排序
        TreeMap<String, String> map1 = new TreeMap<>();
        // 給集合中儲存元素
        map1.put( "affd", "123" );
        map1.put( "fff", "456" );
        map1.put( "ABC", "789" );
        System.out.println( "map1 = " + map1);

        // 建立集合物件，並傳遞比較器，按照指定的方式比較
        TreeMap<String, String> map2 = new TreeMap<>(new Comparator<String>() {
            public int compare(String o1, String o2) {
                // 按照長度比較 ， 相同長度不儲存
                return o1.length() - o2.length();
            }
        });
        // 給集合中儲存元素
        map2.put( "affd", "123" );
        map2.put( "fff", "456" );
        map2.put( "ABC", "789" );
        System.out.println( "map2 = " + map2 );
    }
}

執行結果

map1 = {ABC=789, affd=123, fff=456}
map2 = {fff=789, affd=123}

儲存到TreeMap集合中key值的自定義物件，需要具體比較大小的功能，要實現Comparable介面。並實現其中的compareTo()方法。或者在建立集合時傳遞一個比較器物件。

第二章補充知識點

2.1 JDK9 對集合新增的優化

通常，我們在程式碼中建立一個集合（例如，List 或 Set ），並直接用一些元素填充它。例項化集合，幾個 add方法呼叫，使得程式碼重複。

public class Demo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        list.add("ghi");
        System.out.println(list);
    }
}

Java 9，添加了幾種集合工廠方法,更方便建立少量元素的集合、map例項。

新的List、Set、Map的靜態工廠方法可以更方便地建立集合的不可變例項。

例子：

public class HelloJDK9 {  
    public static void main(String[] args) {  
        Set<String> str1 = Set.of("a","b","c");  
        //str1.add("c");這裡編譯的時候不會錯，但是執行的時候會報錯，因為是不可變的集合  
        System.out.println(str1);  
      
        Map<String,Integer> str2 = Map.of("a",1,"b",2);  
        System.out.println(str2);  
      
        List<String> str3 = List.of("a","b");  
        System.out.println(str3);  
    }  
}

需要注意以下兩點：

1:of()方法只是Map，List，Set這三個介面的靜態方法，其父類介面和子類實現並沒有這類方法，比如 HashSet，ArrayList等。

2:返回的集合是不可變的。

2.2 Debug追蹤

使用IDEA的斷點除錯功能，檢視程式的執行過程

在有效程式碼行，點選行號右邊的空白區域，設定斷點，程式執行到斷點將停止，我們可以手動來執行程式
點選Debug執行模式
程式停止在斷點上不再執行，而IDEA最下方打開了Debug除錯視窗
Debug除錯視窗介紹
快捷鍵F8，程式碼向下執行一行,第九行執行完畢，執行到第10行（第10行還未執行）
切換到控制檯面板，控制檯顯示請錄入一個字串：並且等待鍵盤錄入
快捷鍵F8，程式繼續向後執行，執行鍵盤錄入操作，在控制檯錄入資料 ababcea

回車之後效果：
除錯介面效果：
此時到達findChar方法，快捷鍵F7，進入方法findChar
快捷鍵F8 接續執行，建立了map物件，變數區域顯示
快捷鍵F8 接續執行，進入到迴圈中，迴圈變數i為 0,F8再繼續執行，就獲取到變數c賦值為字元‘a’ 位元組值97
快捷鍵F8 接續執行，進入到判斷語句中，因為該字元不在Map集合鍵集中，再按F8執行，進入該判斷中
快捷鍵F8 接續執行，迴圈結束，進入下次迴圈，此時map中已經新增一對兒元素
快捷鍵F8 接續執行，進入下次迴圈，再繼續上面的操作，我們就可以看到程式碼每次是如何執行的了
如果不想繼續debug,那麼可以使用快捷鍵F9,程式正常執行到結束，程式結果在控制檯顯示

第三章模擬鬥地主洗牌發牌

3.1 案例介紹

按照鬥地主的規則，完成洗牌發牌的動作。

具體規則：

組裝54張撲克牌將
54張牌順序打亂
三個玩家參與遊戲，三人交替摸牌，每人17張牌，最後三張留作底牌。
檢視三人各自手中的牌（按照牌的大小排序）、底牌

規則：手中撲克牌從大到小的擺放順序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

3.2 案例需求分析

準備牌：

為了方便牌的排序，完成數字與紙牌的對映關係：

使用雙列Map(HashMap)集合，完成一個數字與字串紙牌的對應關係(相當於一個字典)。

洗牌：
通過數字完成洗牌發牌
發牌：

將每個人以及底牌設計為ArrayList,將最後3張牌直接存放於底牌，剩餘牌通過對3取模依次發牌。

存放的過程中要求數字大小與鬥地主規則的大小對應。

將代表不同紙牌的數字分配給不同的玩家與底牌。

看牌：

通過Map集合找到對應字元展示。

通過查詢紙牌與數字的對應關係，由數字轉成紙牌字串再進行展示。

3.3 實現程式碼步驟

import java.util.*;

public class ThreadWaitDemo {
    /*
        "♦", "♣", "♥", "♠"
     */
    public static void main(String[] args) {

        // 建立集合，儲存牌和對應的編碼
        HashMap<Integer, String> boxs = new HashMap<>();

        // 建立花色集合，和數字集合
        ArrayList<String> colors = new ArrayList<>();
        ArrayList<String> numbers = new ArrayList<>();
        // 給集合中儲存花色 和 數字
        Collections.addAll( colors,"♦", "♣", "♥", "♠");
        Collections.addAll(numbers,"2","A","K","Q","J","10","9","8","7","6","5","4","3");

        // 定義變數，設定每張牌的大小編號
        int count = 1;
        // 給集合中先儲存最大的兩張牌
        boxs.put(count++, "大王");
        boxs.put(count++, "小王");

        // 迴圈生產牌，儲存到牌盒中
        for( String number : numbers ) {
            for( String color : colors ) {
                // 組合牌
                String card = color + number;
                // 將牌儲存到集合中
                boxs.put(count++, card);
            }
        }

        //System.out.println(boxs);
        // 獲取牌的對應編號，將牌編號的順序打亂
        Set<Integer> number_set = boxs.keySet();

        /*
            因為set集合本身不能呼叫shuffle方法，所以
            將set集合中的資料，儲存到list集合中，然後打亂順序
        */
        // 建立List集合，儲存牌的對應編號
        ArrayList<Integer> number_list = new ArrayList<>();
        number_list.addAll(number_set);
        // 打亂牌的順序
        Collections.shuffle(number_list);


        // 建立三個玩家和底牌集合，儲存對應的牌編號
        ArrayList<Integer> num_p1 = new ArrayList<>();
        ArrayList<Integer> num_p2 = new ArrayList<>();
        ArrayList<Integer> num_p3 = new ArrayList<>();
        ArrayList<Integer> num_diPai = new ArrayList<>();

        // 將牌的編號儲存到玩家和底牌集合中
        for( int i = 0; i < number_list.size(); i++ ) {
            // 將每個編號取出
            Integer num = number_list.get(i);

            // 將獲取的編號儲存到對應的編號集合中
            if( i >= 51 ) {
                num_diPai.add(num);
            } else {
                if( num % 3 == 0 ) {
                    num_p1.add(num);
                } else if( num % 3 == 1 ) {
                    num_p2.add(num);
                } else {
                    num_p3.add(num);
                }
            }
        }

        // 檢視玩家拿到的牌的編號
        System.out.println("diPai = " + num_diPai);
        System.out.println("num_p1 = " + num_p1 );
        System.out.println("num_p2 = " + num_p2 );
        System.out.println("num_p3 = " + num_p3 );

        // 對玩家拿到的牌的編號進行排序
        Collections.sort( num_diPai );
        Collections.sort( num_p1 );
        Collections.sort( num_p2 );
        Collections.sort( num_p3 );

        System.out.println("==================================");

        // 檢視排序後的編號
        System.out.println("diPai = " + num_diPai);
        System.out.println("num_p1 = " + num_p1 );
        System.out.println("num_p2 = " + num_p2 );
        System.out.println("num_p3 = " + num_p3 );

        // 建立3個玩家牌面集合
        ArrayList<String> p1 = new ArrayList<>();
        ArrayList<String> p2 = new ArrayList<>();
        ArrayList<String> p3 = new ArrayList<>();
        ArrayList<String> diPai = new ArrayList<>();

        // 根據玩家獲取的牌的對應編號，從牌盒中找到對應的牌
        for( Integer cardNum : num_p1 ) {
            // 根據玩家一獲取的牌的編號，從牌盒中拿到對應的牌
            String card = boxs.get(cardNum);
            // 將獲取的牌，儲存到玩家1集合中
            p1.add(card);
        }
        for( Integer cardNum : num_p2 ) {
            // 根據玩家一獲取的牌的編號，從牌盒中拿到對應的牌
            String card = boxs.get(cardNum);
            // 將獲取的牌，儲存到玩家1集合中
            p2.add(card);
        }
        for( Integer cardNum : num_p3 ) {
            // 根據玩家一獲取的牌的編號，從牌盒中拿到對應的牌
            String card = boxs.get(cardNum);
            // 將獲取的牌，儲存到玩家1集合中
            p3.add(card);
        }
        for( Integer cardNum : num_diPai ) {
            // 根據玩家一獲取的牌的編號，從牌盒中拿到對應的牌
            String card = boxs.get(cardNum);
            // 將獲取的牌，儲存到玩家1集合中
            diPai.add(card);
        }
        System.out.println("==================================");
        System.out.println("唐三藏  ：" + p1 );
        System.out.println("女兒國王：" + p2 );
        System.out.println("蠍子精  ：" + p3 );
        System.out.println("底牌：" + diPai );
    }
}

day04 【Map】

day04 【Map】

【數論】【二次剩余】【map】hdu6128 Inverse of sum

【Map】HashMap

【 Map】LinkedHashMap

【Map】Hashtable

2761. [JLOI2011]不重復數字【map】

Python(四)語法（list有序可變列表,tuple有序不可變列表,dict字典【MAP】,set）

【Map】【List】【陣列】獲得兩個陣列的交集

Codeforces 730G. Car Repair Shop 【map】

BZOJ4236 JOIOJI 【map】

python 學習筆記【Map 】

HDU1251統計難題【map】

Java Map按照Key和Value排序【轉】

【轉】mybatis循環map的一些技巧

es6 map()和filter()詳解【轉】

【bzoj4200】[Noi2015]小園丁與老司機 STL-map+dp+有上下界最小流

【java】遞歸統計本地磁盤所有文件，提取重復文件，JDK8 map叠代

UVA540 TeamQueue【map+queue】

51nod 1094 和為k的連續區間【前綴和/區間差/map】

【bzoj4165】矩陣堆+STL-map

day04 【Map】

相關推薦