Java集合框架15：Map集合

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/yuming226/article/details/83932708

Map介绍

1、将值映射到值的对象。
2、一个映射不能包含重复的键。
3、每个键最多只能映射到一个值。

Map接口和Collection接口的不同

1、Map是双列的，Collection是单列的。
2、Map的键唯一，Collection的子体系Set是唯一的。
3、Map集合的数据结构值针对键有效，跟值无关；Collection集合的数据结构是针对元素有效。

Map接口定义的方法

1、void clear()：删除该Map对象中的所有key-value对。
2、boolean containsKey(Object key)：查询Map中是否包含指定的key，如果包含返回true。
3、boolean containsValue(Object value)：查询Map中是否包含一个或多个value，如果包含则返回true。
4、Set entrySet()：返回Map中包含的key-value对所组成的Set集合，每个集合元素都是Map.Entry对象。
5、Object get(Object key)：返回指定key所对应的value；如果此Map中不包含该key，则返回null。
6、boolean isEmpty()：查询该Map是否为空，如果为空则返回true。
7、Set keySet()：返回该Map中所有key组成的Set集合。
8、Object put(Object key，Object value)：添加一个key-value对，如果当前Map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对。
9、void putAll(Map m)：将指定Map中的key-value对复制到本Map中。
10、Object remove(Object key)：删除指定key所对应的key-value对，返回被删除key所关联的value，如果该key不存在，则返回null。
11、boolean remove(Object key，Object value)：这是Java8新增的方法，删除指定key、value所对应的key-value对。删除成功返回true，否则返回false。
12、int size()：返回该Map里的key-value对的个数。
13、Collection values()：返回该Map里所有value组成的Collection。

package map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class Dmeo1_Map {
     /**
      * A: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():获取集合中所有值的集合
      * e:长度功能
      *        int size():返回集合中的键值对的个数
      *
      * 注意：map集合是不可以直接迭代的
      */
     
     public static void main(String[] args) {
          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);
          
          Integer value= map.remove("张三");// 根据键删除元素，返回键对应的值
          System.out.println(value);*/
          
          System.out.println(map.containsKey("张三"));//判断是否包含传入的键
          System.out.println(map.containsValue(100));//判断是否包含传入的值
          
          /*Collection<Integer> c = map.values();
          System.out.println(c);
          System.out.println(map.size());
          System.out.println(c.size());*/
          
     }
}

map的遍历

（1）第一种方式：

package map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo2_Iterator {
     /**
      * 通过查看Map集合的api发现没有iterator方法，那么双列集合如何跌该呢？
      */
     public static void main(String[] args) {
          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循环进行遍历
          
          for(String str : map.keySet()) {//map.ketSet()是所有键的集合
              System.out.println(str + ":" + map.get(str));
          }
     }
}

（2）第二种方式

package map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo3_Iterator {
     
     /**
      * Map集合的第二种迭代，根据键值对对象，获取键和值
      *  A:键值对对象找键和值的思路：
      *   获取所有键值对对象的集合
      *   遍历键值对对象的集合，获取到每一个键值对对象
      *   根据键值对对象找键和值
      * @param args
      */
     
     public static void main(String[] args) {
          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();
              String key = en.getKey();                       //根据键值对对象获取键
              Integer value = en.getValue();                  //根据键值对对象获取值
              System.out.println(key + ":" + value);
          }*/
          
          for(Map.Entry<String, Integer> en : map.entrySet()) {
              System.out.println(en.getKey() + ":" + en.getValue());
          }
     }
}

HashMap示例演示

package map;
import java.util.HashMap;
public class Demo5_HashMap {
     /*
      * A:案例演示
      * HashMap集合键是Student值是String的案例
      * 键是学生对象，代表一个学生
      * 值是字符串对象，代表学生归属地
      */
     public static void main(String[] args){
          HashMap<Student,String> hm = new HashMap<>();
          hm.put(new Student("张三",23), "北京");
          hm.put(new Student("张三",23),"上海");
          hm.put(new Student("李四",24), "广州");
          hm.put(new Student("王五",25),"北京");
          
          System.out.println(hm);
              
     }
}

LinkedHashMap示例演示

package map;
import java.util.LinkedHashMap;
public class Demo6_LinkedHashMap {
     /**
      * LinkedHashMap保证了怎么存就怎么取
      * @param args
      */
     public static void main(String[] args) {
          LinkedHashMap<String,Integer> lhm = new LinkedHashMap<>();
          lhm.put("张三", 23);
          lhm.put("李四", 24);
          lhm.put("赵六", 26);
          lhm.put("王五", 25);
          
          System.out.println(lhm);
     }
}

TreeMap示例演示

package map;
import java.util.TreeMap;
importjava.util.Comparator;
public class Dmeo7_TreeMap {
     /**
      * TreeMap集合键是Student值是String的案例
      * @param args
      */
     
     public static void main(String[] args) {
          TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>() {
              @Override
              public int compare(Student s1, Student s2) {
                   int num = s1.getName().compareTo(s2.getName()); //按照姓名比较
                   return num == 0 ? s1.getAge() - s2.getAge() : num;
              }
          });
          
          tm.put(new Student("张三",23), "北京");
          tm.put(new Student("李四",13), "上海");
          tm.put(new Student("王五",33), "广州");
          
          System.out.println(tm);
     }
     
     public void demo() {
          TreeMap<Student,String> tm = new TreeMap<>();
          tm.put(new Student("张三",23), "北京");
          tm.put(new Student("李四",13), "上海");
          tm.put(new Student("王五",33), "广州");
          
          System.out.println(tm);
     }
}

统计字符串中每个字符出现的次数

package map;
import java.util.HashMap;
public class Test1 {
     /**
      * A:案例演示
      * 需求：统计字符串中每个字符出现的次数
      *
      * 分析：
      * 1，定义一个需要被统计字符的字符串
      * 2，将字符串转换为字符数组
      * 3，定义双列集合，存储字符串中字符以及字符出现的次数
      * 4,遍历字符数组获取一个字符，并将字符存储在双列集合中
      * 5，存储过程中要判断，如果集合中不包含这个键，就将该字符当作键，值为1存储，如果集合中包含这个键，就将值加1存储
      * 6，打印双列集合中获取字符出现的次数
      */
     
     public static void main(String[] args) {
          //1，定义一个需要被统计字符的字符串
          String s = "aaaabbbbbbccccccccccccccccccccccc";
          
          //2,将字符串转换为字符数组
          char[] arr = s.toCharArray();
          
          //3，定义双列集合，存储字符串中字符以及字符出现的次数
          HashMap<Character,Integer> hm = new HashMap<>();
          
          //4,遍历字符数组获取每一个字符，并将字符串存储在双列集合中
          
          for(char c : arr) {
              //5，存储过程中要判断，如果集合中不包含这个键，就将该字符当作键，值为1存储，如果集合中包含这个键，就将值加1存储
              /*if(!hm.containsKey(c)) {
                   hm.put(c,1);
              } else {
                   hm.put(c, hm.get(c) + 1);
              }*/
              hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
          }
          
          System.out.println(hm);
          //6，打印双列集合中获取字符出现的次数
          
          for(Character key : hm.keySet()) {//hm.keySet()代表所有键的集合
              System.out.println(key + "=" + hm.get(key));//hm.get(key)根据键获取值
          }
     }
}

HashMap和Hashtable的区别

package map;
import java.util.HashMap;
import java.util.Hashtable;
public class Demo9_Hashtable {
     /**
      * 面试题：
      * HashMap和Hashtable的区别
      * 共同点：
      * 底层都是哈希算法，都是双列集合
      * 区别：
      * 1，HashMap是线程不安全的，效率高，JDK1.2版本
      * Hashtable是线程安全的，效率低，JDK1.0版本
      * 2，HashMap可以存储null键和null值
      * Hashtable不可以存储null键和null值
      */
     
     public static void main(String[] args) {
          HashMap<String,Integer> hm = new HashMap<>();
          hm.put(null, 23);
          hm.put("李四", null);
          System.out.println(hm);
          
          Hashtable<String,Integer> ht = new Hashtable<>();
          ht.put("张三", null);
     }
}