​目录​

​​1、Map 集合特点​​

​​2、Map接口中的常用方法​​

​​3、Map 集合遍历方式 keySet 方法​​

​​4、Map 集合 Entry 对象使用 entrySet 方法遍历​​

​​5、HashMap 集合存储自定义对象和遍历​​

​​6、LinkedHashMap 的特点​​

​​7、Hashtable 的特点​​

Map 集合和 Collection 集合不同，Map 集合是基于键（key）/值（value）的映射，Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储；Map中的集合，元素是成对存在的，每个元素由键与值两部分组成，通过键可以找对所对应的值。Collection中的集合称为单列集合，Map中的集合称为双列集合。需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

1、Map 集合特点


  • 每个元素成对存在，由键和值两部分组成，通过键可以找到对应的值
  • 键（key值）不可重复，值（value）可以重复，一个value值可以和很多key值形成对应关系，每个建最多只能映射到一个值
  • 两个 Map 接口的重要实现类：HashMap 类、LinkedHashMap 类

2、Map接口中的常用方法


  • get(Object key)：获取指定键(key)所对应的值(value)
  • put(K key，V value)：将指定的键与值对应起来，并添加到集合中
    若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中
    若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值
  • remove(Object key)：根据指定的键(key)删除元素，返回被删除元素的值(value)

public static void main(String[] args)
{
    //创建Map对象
    Map<String,String> M = new HashMap<>();
    //添加元素
    M.put("汤姆","Tom");
    M.put("提姆","Tim");
    M.put("瑞克","Rik");
    System.out.println(M);

    //根据指定的key获取对应的value
    System.out.println(M.get("汤姆"));

    //根据key删除元素,会返回key对应的value值
    String val = M.remove("提姆");
    System.out.println(val);
    System.out.println(M);

    //当给Map中添加元素，会返回key对应的原来的value值,若key没有对应的值，返回null
    System.out.println(M.put("汤姆","TTT"));  //Tom
    System.out.println(M);
}

3、Map 集合遍历方式 keySet 方法

Map 集合中遍历是通过键找值的方法来实现的，即：通过元素中的键，获取键所对应的值，步骤如下：


  • 调用 Map 集合的方法 keySet，将所有的键（key值）存储到Set集合中
  • 遍历 Set 集合，获取出 Set 集合中的所有元素 ( Map 中的键（key值）)
  • 调用 Map 集合 get 方法，通过键（key值）获取到值（value值）

public static void main(String[] args)
{
    //创建Map集合并添加元素
    Map<Integer,String> M = new HashMap<>();
    M.put(1,"a");
    M.put(2,"b");
    M.put(3,"c");

    //1. 调用 Map 集合的方法 keySet，将所有的键（key值）存储到Set集合中
    Set<Integer> S = M.keySet();

    //2.遍历 Set 集合，获取出 Set 集合中的所有元素 ( Map 中的键（key值）)
    Iterator<Integer> it = S.iterator();
    while (it.hasNext())
    {
        //获取Map中的键
        Integer key = it.next();
        //3.调用 Map 集合 get 方法，通过键（key值）获取到值（value值）
        String value = M.get(key);
        System.out.println(key + "=" + value);
    }
}

当然，也可以使用增强for

for(String key : map.keySet())
{
    Integer value = map.get(key);
    System.out.println(key+"="+value);
}

4、Map 集合 Entry 对象使用 entrySet 方法遍历

在 Map 类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象，即键值对对象，这样我们在遍历 Map 集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

Entry是Map的一个内部接口，由Map的子类的内部类实现，可以使用 Map 接口中的 entrySet 方法返回一个 Entry 对象

interface Map{
    interface Entry{      

    }
}

Entry 对象特点：


  • Entry是Map接口中提供的一个静态内部嵌套接口
  • 相关方法
         getKey()方法：获取Entry对象中的键
         getValue()方法：获取Entry对象中的值
         entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回

Map 集合遍历方式 entrySet 方法：


  • 调用 Map 集合方法 entrySet() 将集合中的映射关系对象 Entrty 存储到Set集合：Set<Entry <K,V> >
  • 迭代 Set 集合
  • 获取出的 Set 集合的元素，是映射关系对象
  • 通过映射关系对象方法 getKet, getValue 获取键值对

public static void main(String[] args)
{
    //创建Map集合并存储元素
    Map<Integer,String> M = new HashMap<>();
    M.put(1,"a");
    M.put(2,"b");
    M.put(3,"c");
    //1.调用 Map 集合方法 entrySet() 将集合中的映射关系对象 Entrty 存储到Set集合：Set<Entry <K,V> >
    Set<Map.Entry<Integer,String>> S = M.entrySet();
    //2.迭代 Set 集合
    Iterator<Map.Entry<Integer,String>> it = S.iterator();
    while (it.hasNext())
    {
        //3.获取出的 Set 集合的元素的映射关系对象
        Map.Entry<Integer,String> entry = it.next();
        //4.通过映射关系对象方法 getKet, getValue 获取键值对
        Integer key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + "=" + value);
    }
}

5、HashMap 集合存储自定义对象和遍历

使用HashMap集合,存储自定义的对象，这个自定义对象既可以作为键，也可以作为值（注意要保证键的唯一性）

代码实例（这里省略了Person类）

public static void main(String[] args)
{
     //创建Map集合用来存储创建的对象
     Map<Integer,Person> M = new HashMap<>();
     M.put(1,new Person("Tom",18));
     M.put(2,new Person("Tim",19));
     M.put(3,new Person("Rik",20));
     //这里使用增强for进行遍历
     //1.使用keySet键找值方式遍历
    for(Integer key : M.keySet())
    {
        Person value = M.get(key);
        System.out.println(key + "=" + value);
    }
    //2.使用entrySet 键值对方式遍历
    for(Map.Entry<Integer,Person> entry : M.entrySet())
    {
        Integer key = entry.getKey();
        Person value = entry.getValue();
        System.out.println(key + "=" + value);
    }
}

  • 当给 HashMap 中存放自定义的对象时，如果自定义对象作为键（key）存在，这时要保证对象唯一性，必须将对象的 hashCode 和 equals 方法重写
  • 如果要保证 Map 中存放的 key 和取出的顺序一致，可以使用 LinkedHashMap 集合来存储

6、LinkedHashMap 的特点

  • LinkedHashMap继承HashMap，能够保证迭代的顺序
public static void main(String[] args) {
  LinkedHashMap<String, String> link = new LinkedHashMap<String, String>();
  link.put("1", "a");
  link.put("13", "a");
  link.put("15", "a");
  link.put("17", "a");
  System.out.println(link);
}

7、Hashtable 的特点


  • 是 Map 接口实现类
  • 底层数据结果哈希表,特点和 HashMap 是一样的
  • Hashtable 是线程安全集合，运行速度慢（HashMap 线程不安全，运行速度快）
  • Hashtable 命运和Vector是一样的,从JDK1.2开始，被更先进的 HashMap 取代
  • Hashtable 不允许存储 null 值，null 键（HashMap 允许存储 null 值，null 键）
  • Hashtable的子类 Properties 比较常用