Java-Map集合

1. map集合

• HashMa集合 实现类 ------(LinkHashMap集合(实现类))
• TreeMap 集合 实现类
• Hash Table 集合 实现类

Map接口

• public interface Map<K,V>
  将键映射到值的对象。 Map不能包含重复的键。每个键可以映射到最多一个值。

• 举例：
  <K,V> 键值对
  1001 李毅
  1002 小虎
  1002 李毅(不允许的)

面试题--Ma接口与Collection接口区别？

• 1、他们都是属于java.util包下的，Map接口与Collection接口属于平级关系，不存在继承关系
• 2、Map集合中存储的元素都是成对出现的，Map集合中的键是唯一的，值是可以重复，有些书籍把键值对称之为夫妻对
• 3、Collection集合中的元素都是单独出现的，Collection下Set相关集合元素是唯一的，List相关集合元素是可以重复的像这样单独出现的元素，称之为光棍。

Map相关集合的方法：

• 1、添加功能：
  V put(K key, V value) 将指定的值与该映射中的指定键相关联(可选操作)。
  举例：map.put("1001","小虎");
• 2、删除功能
  void clear() 从该map中删除所有的映射(可选操作)。
  V remove(Object key) 如果存在(从可选的操作)，从该地图中删除一个键的映射。
• 3、判断功能
  boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
  boolean containsValue(Object value) 如果此map将一个或多个键映射到指定的值，则返回 true 。
  boolean isEmpty() 如果此map不包含键值映射，则返回 true 。
• 4、获取功能
  V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
  Set<Map.Entry<K,V>> entrySet() 返回此map中包含的映射的Set视图。
  Set keySet() 返回此map中包含的键的Set视图。
  Collection values() 返回此map中包含的值的Collection视图。
• 5、长度功能
  int size() 返回此map中键值映射的数量。

注意：
        api所说的映射指的是一个键值对

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
        Map集合练习
 */
public class MapDemo1 {
    public static void main(String[] args) {
        //创建一个Map集合
         Map<Integer, String> sMap = new HashMap<>();
         //向集合中添加元素
//        sMap.put(1001, "阿涛");
        //Map集合的Put方法返回的是：以前与key关联的值，就是前妻
        //第一次返回null,是因为之前与001关联的值没有，所以返回null
        //第二次值由zhangsan变成了wangwu,所以返回之前的值，即zhangsan
        System.out.println(sMap.put(1001, "阿涛"));
        System.out.println(sMap);
        System.out.println("=====================================");
        sMap.put(1001, "红");
        sMap.put(1002, "橙");
        sMap.put(1003, "黄");
        sMap.put(1004, "绿");
        sMap.put(1005, "青");
        sMap.put(1006, "蓝");
        System.out.println(sMap);
        System.out.println("=======================================");
        //void clear() 从该地图中删除所有的映射(可选操作)。
        //sMap.clear();
        //System.out.println(sMap); // 返回 {}
        System.out.println("========================================");
        //int size() 返回此地图中键值映射的数量。
        //System.out.println(sMap.size()); // 6
        System.out.println("========================================");
        //Collection<V> values() 返回此地图中包含的值的Collection视图。
        Collection<String> values = sMap.values();
        //遍历 values 集合
        for(String str :values){
            System.out.println(str);
        }
        //Set<K> keySet() 返回此地图中包含的键的Set视图。
        Set<Integer> integers = sMap.keySet();
        for(Integer i: integers){
            System.out.println(i);
        }
        System.out.println("========================================");
        //default boolean replace(K key, V oldValue, V newValue)
        //仅当当前映射到指定的值时，才能替换指定键的条目。
        System.out.println(sMap.replace(1002, "橙", "小橙"));
        System.out.println(sMap);
        System.out.println("========================================");
        System.out.println(sMap.replace(1004, "小绿"));
        System.out.println(sMap);
        //boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
        System.out.println(sMap.containsKey(1004)); //true
        System.out.println("===========================================");
        //Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。
        Set<Map.Entry<Integer, String>> entries = sMap.entrySet();
        for (Map.Entry<Integer, String> entry : entries){
            System.out.println(entry);
        }
    }
}

package com.bigdat.java.day22;
import java.util.HashMap;
public class MapDemo01 {
    public static void main(String[] args) {
        //创建Map集合对象
        //由于map是一个接口不能被直接实例化，所以要找一个该接口的具体实现子类，利用接口多态的形式创建对象
        HashMap<Integer, String> map = new HashMap<>();
        //V put(K key, V value) 将指定的值与该映射中的指定键相关联(可选操作)
        //向集合中添加元素
        //返回的是该键对应的被覆盖的历史的值
        //多次添加同一个key映射的时候，key只能有一个，值直接被覆盖
        System.out.println(map.put(1001, "阿涛")); //null
        System.out.println(map.put(1001, "阿涛"));//阿涛 //添加相同的值。会被覆盖
        System.out.println("该集合中的键值对的数量是："+map.size());
        map.put(1002, "美羊羊");
        map.put(1003, "灰太狼");
        map.put(1004, "小灰灰");
        map.put(1005, "刀羊爷爷");
        map.put(1006, "老村长");
        System.out.println(map);
        System.out.println("==================================");
        //void clear() 从该map中删除所有的映射(可选操作)。
       // map.clear();
       // System.out.println(map); // {}
        System.out.println("===================================");
        //V remove(Object key) 如果存在(从可选的操作)，从该地图中删除一个键的映射。
        //返回的是被删除的key对应的值，并且整个映射从map集合中移除
        //System.out.println(map.remove(1003)); //返回值是被删除的元素 灰太狼
        //System.out.println(map); // {1001=阿涛, 1002=美羊羊, 1004=小灰灰, 1005=刀羊爷爷, 1006=老村长}
        //如果要删除的key在集合中不存在，不会报错，返回的是value类型的默认值 null
        //System.out.println(map.remove(1008));//null
        //System.out.println(map);
        System.out.println("=============================================");
        //boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
        System.out.println(map.containsKey(1005)); //true
        System.out.println(map.containsKey(1009)); // false
        System.out.println("========================================");
        //boolean containsValue(Object value) 如果此map将一个或多个键映射到指定的值，则返回 true 。
        System.out.println(map.containsValue("小灰灰")); //true
        System.out.println(map.containsValue("小红娘")); //false
        System.out.println("========================================");
        System.out.println(map.isEmpty());


    }
}

Map集合想关的获取功能

• 1.V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
• 2.Set<Map.Entry<K,V>> entrySet() 返回此map中包含的映射的Set视图。
• 3.Set keySet() 返回此map中包含的键的Set视图。
• 4.Collection values() 返回此map中包含的值的Collection视图。

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

public class MapDemo02 {
    public static void main(String[] args) {
        //创建 Map 集合的相关对象
        Map<Integer, String> map = new HashMap<>();
        //向集合中添加元素
        map.put(1001, "唐三藏");
        map.put(1002, "孙悟空");
        map.put(1003, "沙僧");
        map.put(1004, "猪八戒");
        map.put(1005, "牛魔王");
        //V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
        //通过键找值
        System.out.println(map.get(1001));
        System.out.println(map.get(1006)); // null 如果map集合中不存在指定的值返回null
        System.out.println("=======================================================");
        //Set<K> keySet() 返回此map中包含的键的Set视图。
        //获取map中所有的键
        //因为我们map集合中的key是不允许重复的，是唯一的，所以该方法调用完后返回的集合是Set相关集合
        Set<Integer> integers = map.keySet();
        for (Integer integer : integers) {
            System.out.println(integer);
        }
        System.out.println("=========================================================");
        //Collection<V> values() 返回此map中包含的值的Collection视图。
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }
    }
}

Map 集合遍历的两种方式

方式一：先获取键，在通过键找值

package com.bigdat.java.day22;
import java.util.*;
/*
    map集合遍历的方式
        方式1：根据键找值
            获取所有键的集合 ---> map集合中的keySet()
            遍历键的集合，获取到每一个键 ---> 增强for循环/迭代器
            根据键找值 ---> map集合中的get()方法
 */
public class MapDemo03 {
    public static void main(String[] args) {
        //创建 map 集合对象
        Map<String, String> map = new HashMap<>();
        //向集合中添加元素
        map.put("胡歌","刘亦菲");
        map.put("彭于晏","许晴");
        map.put("成龙","刘诗诗");
        map.put("张杰","谢娜");
        map.put("曾小贤","胡一菲");
        //开始遍历集合
        //获取集合中的键
        Set<String> strings = map.keySet();
        for (String string : strings) {
            String s = map.get(string);
            System.out.println("男:"+string+"，女："+s);
        }
        System.out.println("================================");
        //迭代器遍历
        //首先迭代键，然后再根据键获取值
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            String s = map.get(next);
            System.out.println("男："+next+",女："+s);
        }
    }
}

方式二：通过键值对的对象，找到键和值

package com.bigdat.java.day22;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
        map集合遍历的方式：
        方式2：根据键值对对象找键和值
            获取所有键值对对象的集合
            遍历键值对对象的集合，获取到每一个键值对对象
            根据键值对对象找键和值
 */
public class MapDemo04 {
    public static void main(String[] args) {
        //创建 map 集合的对象
        Map<Integer, String> map = new HashMap<>();
        //向集合中添加元素
        map.put(101,"逃学威龙");
        map.put(102,"九品芝麻官");
        map.put(103,"赌圣");
        map.put(104,"功夫");
        map.put(105,"周星星");
        //根据键值对的对象赵键和值
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        //for 循环
        for (Map.Entry<Integer, String> entry : entries) {
            String value = entry.getValue();
            final Integer key = entry.getKey();
            System.out.println("键："+entry.getKey()+"\t值："+entry.getValue());
        }
        System.out.println("======================================");
        //迭代器
        Iterator<Map.Entry<Integer, String>> iterator = entries.iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer, String> next = iterator.next();
            Integer key = next.getKey();
            String value = next.getValue();
            System.out.println("键："+key+",值："+value);
        }
    }
}