在實際需求中，我們常常會遇到這樣的問題，在諸多的資料中，通過其編號來尋找某一些資訊，從而進行檢視或者修改，例如通過學號查詢學生資訊。今天我們所介紹的Map集合就可以很好的幫助我們實現這種需求

(一) 概述及功能

(1) 概述

Map是一種儲存元素對的集合（元素對分別稱作 鍵 和 值 也稱鍵值對）它將鍵對映到值的物件。一個對映不能包含重複的鍵，並且每個鍵最 多隻能對映到一個值。

怎麼理解呢？

鍵 (key)：就是你存的值的編號 值 (value)：就是你要存放的資料

你可以近似的將鍵理解為下標，值依據鍵而儲存，每個鍵都有其對應值。這兩者是1、1對應的

但在之前下標是整數，但是Map中鍵可以使任意型別的物件。

Map集合和Collection集合的區別?

• Map集合儲存元素是成對出現的，Map集合的鍵是唯一的，值是可重複的
• Collection集合儲存元素是單獨出現的，Collection的子類Set是唯一的，List是可重複的。
• Map集合的資料結構值針對鍵有效，跟值無關，Collection集合的資料結構是針對元素有效

(2) 功能

A：新增功能

//新增元素
V put(K key,V value)   
    
//如果鍵是第一次儲存，就直接儲存元素，返回null
//如果鍵不是第一次存在，就用值把以前的值替換掉，返回以前的值 

B：刪除功能

//移除所有的鍵值對元素
void clear()

//根據鍵刪除鍵值對元素，並把值返回
V remove(Object key)
 

C：判斷功能

//判斷集合是否包含指定的鍵
boolean containsKey(Object key)

//判斷集合是否包含指定的值
boolean containsValue(Object value)

//判斷集合是否為空
boolean isEmpty()

D：獲取功能

//將map集合中的鍵和值對映關係打包為一個物件
Set<Map.Entry<K,V>> entrySet()

//根據鍵獲取值
V get(Object key)

//獲取集合中所有鍵的集合
Set<K> keySet()

//獲取集合中所有值的集合
Collection<V> values()
 

E：長度功能

//返回集合中的鍵值對的對數
int size()

(二) Map集合的遍歷

package cn.bwh_01_iterator;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {
    public static void main(String[] args) {
        Map<String, String> hm = new HashMap<String, String>();
        hm.put("bwh002", "i");
        hm.put("bwh001", "love");
        hm.put("bwh003", "you");

        //方式一 鍵找值
        Set<String> set = hm.keySet();

        //迭代器遍歷
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            String value = hm.get(key);
            System.out.println(key + "---" + value);
        }

        //增強for遍歷
        for (String key : set) {
            String value = hm.get(key);
            System.out.println(key + "---" + value);
        }

        //方式二 鍵值對物件找鍵和值（推薦）
        Set<Map.Entry<String, String>> set2 = hm.entrySet();

        //迭代器遍歷
        Iterator<Map.Entry<String, String>> it2 = set2.iterator();
        while (it2.hasNext()) {
            //返回的是封裝了key和value物件的Map.Entry物件
            Map.Entry<String, String> entry = it2.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "---" + value);

        }

        //增強for遍歷
        for (Map.Entry<String, String> me : set2) {
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "---" + value);
        }
    }
}

(三) Map及子類總結

Map（雙列集合）

• Map集合的資料結構僅僅針對鍵有效，與值無關。

• 儲存的是鍵值對形式的元素，鍵唯一，值可重複

HashMap

• 底層資料結構是雜湊表，執行緒不安全，效率高

• 雜湊表依賴兩個方法：hashCod()和equals()

• 執行順序：

  • 首先判斷hashCode()值是否相同
    • 是：繼續執行equals(),看其返回值
      • 是true：說明元素重複，不新增
      • 是false：就直接新增到集合
    • 否：就直接新增到集合

• 最終：

• 自動生成hashCode()和equals()即可

LinkeHashMap

• 底層資料結構是由連結串列和雜湊表組成

• 由連結串列保證元素有序

• 由雜湊表保證元素唯一

Hashtable

• 底層資料結構是雜湊表
• 雜湊表依賴兩個......自動生成hashCode()和equals()即可

TreeMap

• 底層資料結構是紅黑樹（是一種自平衡的二叉樹）

如何保證元素唯一性呢？

• 根據比較的返回值是否是0來決定

如何保證兩種元素的排序呢？

• 自然排序（元素具備比較性）
  • 讓元素所屬的類實現comparable介面
• 比較器排序（集合具備比較性）
  • 讓集合接收一個comparator的實現類物件

可以多層巢狀

HashMap集合巢狀HashMap

HashMap集合巢狀ArrayList

ArrayList集合巢狀HashMap

HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>

1:Hashtable和HashMap的區別?

**Hashtable**:執行緒安全，效率低。不允許null鍵和null值

**HashMap**:執行緒不安全，效率高。允許null鍵和null值

​

(其實HashMap就是用來替代Hashtable的，就像ArrayList替代vector一樣)

2:List,Set,Map等介面是否都繼承子Map介面?

List，Set不是繼承自Map介面，它們繼承自Collection介面

Map介面本身就是一個頂層介面

需要排序：TreeMap

不需要排序：HashMap

不知道具體需求：HashMap

(四) 經典案例

(1) 統計字串中字元出現的次數

import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

/*
 * 案例（統計字串中字元出現的次數）
 * 需求：
 *      獲取一個字串出現的次數
 * 分析：
 *      A：定義一個字串（或者鍵盤錄入）
 *      B: 定義一個TreeMap集合
 *              鍵：Character
 *              值：Integer
 *      C：把字串轉換為字元陣列
 *      D: 遍歷字元陣列，得到每一個字元
 *      E: 拿剛才得到的字元作為鍵去集合中找，看返回值
 *              是 null：說明該鍵不存在,就把該字串作為鍵，1作為值去儲存
 *              不是 null：說明該鍵存在，就把值加 1 然後重寫儲存該鍵和值
 *      F: 定義字串緩衝區變數
 *      G：遍歷集合，得到該建和值，按照要求拼接
 *      H：最後把字串緩衝區轉換為字串輸出
 */
 
public class CountDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入需要統計的資料");
        String line = sc.nextLine();

        Map<Character, Integer> tm = new TreeMap<Character, Integer>();
        char[] chs = line.toCharArray();
        for (char ch : chs) {
            Integer i = tm.get(ch);
            if (i == null) {
                tm.put(ch, 1);
            } else {
                i++;
                tm.put(ch, i);
            }
        }

        StringBuilder s = new StringBuilder();
        Set<Character> set = tm.keySet();
        for (Character key : set) {
            Integer value = tm.get(key);
            s.append(key).append("(").append(value).append(")" + " ");
        }
        String result = s.toString();
        System.out.println("result: " + result);
    }
}

//執行結果
請輸入需要統計的資料
HelloWorld
result: H(1) W(1) d(1) e(1) l(3) o(2) r(1) 

(2) 模擬鬥地主案例

在講解這個案例之前，我們先來了解一個我們下面案例中所需要知道的知識點

Collections 工具類

Collections:是針對集合進行操作的工具類，都是靜態方法。

面試題：

Collection和Collections的區別?

Collection:是單列集合的頂層介面，有子介面List和Set。(Map是雙列的)

Collections:是針對集合操作的工具類，有對集合進行排序和二分查詢的方法

Collections的靜態方法

//排序 預設情況下是自然順序。
public static <T> void sort(List<T> list)

//二分查詢
public static <T> int binarySearch(List<?> list,T key)

//最大值
public static <T> T max(Collection<?> coll)

//反轉(逆序排序)
public static void reverse(List<?> list)

//隨機置換(猶如洗牌，每次執行結果不一樣)
public static void shuffle(List<?> list)

如果同時有自然排序和比較器排序，以比較器排序為主(也就是說，當同時實現了Student類的自然排序(implements Comparable<Student>)以及比較器排序的話(new Comparator<Student>())，比較器排序會覆蓋自然排序)

//鬥地主案例程式碼
package cn.bwh_03_PokerGame;

import java.util.*;

public class PokerGame {
    public static void main(String[] args) {
        HashMap<Integer, String> hm = new HashMap<Integer, String>();
        ArrayList<Integer> array = new ArrayList<Integer>();

        String[] colors = {"♥", "♠", "♣", "♦"};
        String[] numbers = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};

        int index = 0;
        for (String number : numbers) {
            for (String color : colors) {
                String poker = color.concat(number);
                hm.put(index, poker);
                array.add(index);
                index++;
            }
        }

        hm.put(index, "小王");
        array.add(index);
        index++;
        hm.put(index, "大王");
        array.add(index);
        index++;

        //洗牌
        Collections.shuffle(array);

        //發牌（發的是編號，為了保證編號是排序的，使用TreeSet接收）
        TreeSet<Integer> player1 = new TreeSet<Integer>();
        TreeSet<Integer> player2 = new TreeSet<Integer>();
        TreeSet<Integer> player3 = new TreeSet<Integer>();
        TreeSet<Integer> handcards = new TreeSet<Integer>();

        for (int x = 0; x < array.size(); x++) {
            if (x >= array.size() - 3) {
                handcards.add(array.get(x));
            } else if (x % 3 == 0) {
                player1.add(array.get(x));
            } else if (x % 3 == 1) {
                player2.add(array.get(x));
            } else if (x % 3 == 2) {
                player3.add(array.get(x));
            }
        }

        System.out.println("---------------------歡樂鬥地主----------------------");
        //看牌(遍歷TreeSet集合，獲取編號，到HashMap集合找對應的牌)
        lookpocker("player1", player1, hm);
        lookpocker("player2", player2, hm);
        lookpocker("player3", player3, hm);
        lookpocker("預留", handcards, hm);
    }

    //看牌功能實現
    public static void lookpocker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) {
        System.out.println(name + "的牌是：");
        for (Integer key : ts) {
            String value = hm.get(key);
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

結尾：

如果內容中有什麼不足，或者錯誤的地方，歡迎大家給我留言提出意見, 蟹蟹大家 ！^_^

如果能幫到你的話，那就來關注我吧！（系列文章均會在公眾號第一時間更新）

在這裡的我們素不相識，卻都在為了自己的夢而努力 ❤

一個堅持推送原創Java技術的公眾號：理想二旬不止

相關推薦