Map集合概述和特點

  A：Map集合概述和特點(Set底層依賴的是Map)

• 將鍵映射到值的對象
• 一個映射不能包含重復的鍵
• 每個鍵最多只能映射到一個值

B:Map接口和Collection接口的不同

• Map是雙列的(是雙列集合的根接口),Collection是單列的(是單列集合的根接口)
• Map的鍵唯一,Collection的子體系Set是唯一的
• Map集合的數據結構值針對鍵有效，跟值無關;如:TreeMap:鍵是用二叉樹算法,HashMap:鍵是hash算法, Collection集合的數據結構是針對元素有效

圖解：

 

Map集合的功能概述

   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:獲取元素功能

• Set<Map.Entry<K,V>> entrySet():
• V get(Object key):根據鍵獲取值
• Set<K> keySet():獲取集合中所有鍵的集合
• Collection<V> values():獲取集合中 * int size()：返回集合中的鍵值對的個數所有值的集合

package online.msym.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class Demo1_Map {    
    public static void main(String[] args) {
        //demo1();//添加數據
        //demo2();//刪除數據,判斷是否包含鍵或者值
        demo3();//獲取map中的所有的值
    }
    private static void demo3() {
        Map<String, Integer> map = new HashMap<>();
        map.put("張三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("趙六", 26);
        
        Collection<Integer> c = map.values();
        System.out.println(c);
        System.out.println(map.size());
    }
    public static void demo2() {
        Map<String, Integer> map = new HashMap<>();
        map.put("張三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("趙六", 26);
        
        //Integer value = map.remove("張三");                //根據鍵刪除元素,返回鍵對應的值
        //System.out.println(value);
        System.out.println(map.containsKey("張三"));        //判斷是否包含傳入的鍵
        System.out.println(map.containsValue(100));        //判斷是否包含傳入的值
        System.out.println(map);
    }
    public static void demo1() {
        Map<String, Integer> map = new HashMap<>();
        Integer i1 = map.put("張三", 23);//存入的過程先判斷有沒有"張三",沒有就添加,有就覆蓋,返回的是被覆蓋的部分
        Integer i2= map.put("李四", 24);
        Integer i3 = map.put("王五", 25);
        Integer i4 = map.put("趙六", 26);
        Integer i5 = map.put("張三", 26);                    //相同的鍵不存儲,值覆蓋,把被覆蓋的值返回
        
        System.out.println(map);
        
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);
    }
}

Map集合的遍歷之鍵找值

A:鍵找值思路：

1. 獲取所有鍵的集合
2. 遍歷鍵的集合，獲取到每一個鍵
3. 根據鍵找值

圖解：

package online.msym.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo2_Iterator {
    /**
     * Map集合沒有iterator方法,
     * 根據鍵獲取值
     */
    public static void main(String[] args) {
        //demo1();//使用keySet方法,通過獲取所有的鍵的集合,在遍歷此集合,根據鍵再獲取其對應的值
        demo2();
    }
    private static void demo1() {
        Map<String, Integer> map = new HashMap<>();
        map.put("張三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("趙六", 26);        
//        Integer i = map.get("張三");                    //根據鍵獲取值
//        System.out.println(i);
        
        //獲取所有的鍵
        Set<String> keySet = map.keySet();            //獲取所有鍵的集合
        Iterator<String> it = keySet.iterator();    //獲取迭代器
        while(it.hasNext()) {                        //判斷集合中是否有元素
            String key = it.next();                    //獲取每一個鍵
            Integer value = map.get(key);            //根據鍵獲取值
            System.out.println(key + "=" + value);
        }        
    }
    //使用增強for循環
    private static void demo2() {
        Map<String, Integer> map = new HashMap<>();
        map.put("張三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("趙六", 26);        
        //使用增強for循環遍歷
        for(String key : map.keySet()) {            //map.keySet()是所有鍵的集合
            System.out.println(key + "=" + map.get(key));
        }
    }
}

Map集合的遍歷之鍵值對對象找鍵和值

A:鍵值對對象找鍵和值思路：

1. 獲取所有鍵值對對象的集合
2. 遍歷鍵值對對象的集合，獲取到每一個鍵值對對象
3. 根據鍵值對對象找鍵和值

   

package online.msym.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Demo3_Iterator {
    /**
     * Map集合的第二種迭代,根據鍵值對對象,獲取鍵和值
     *  A:鍵值對對象找鍵和值思路：
        獲取所有鍵值對對象的集合
        遍歷鍵值對對象的集合，獲取到每一個鍵值對對象
        根據鍵值對對象找鍵和值
     */
    public static void main(String[] args) {
        //demo1();
        demo2();
    }
    public static void demo1() {
        Map<String, Integer> map = new HashMap<>();
        map.put("張三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("趙六", 26);
        
        //Map.Entry說明Entry是Map的內部接口,將鍵和值封裝成了Entry對象,並存儲在Set集合中
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        //獲取每一個對象
        Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
        while(it.hasNext()) {
            //獲取每一個Entry對象
            Map.Entry<String, Integer> en = it.next();    //父類引用指向子類對象
            //Entry<String, Integer> en = it.next();    //直接獲取的是子類對象
            String key = en.getKey();                    //根據鍵值對對象獲取鍵
            Integer value = en.getValue();                //根據鍵值對對象獲取值
            System.out.println(key + "=" + value);
        }    
    }
    //使用增強for循環進行迭代
    public static void demo2() {
        Map<String, Integer> map = new HashMap<>();
        map.put("張三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("趙六", 26);    
        //使用增強for循環進行迭代
        for(Map.Entry<String, Integer> en : map.entrySet()) {
            System.out.println(en.getKey() + "=" + en.getValue());
        }    
    }
}

【點擊此處回到主頁】