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());
        }    
    }
}

【点击此处回到主页】