基础系列【十四】--Map映射

映射–Map<K,V>

1. K--键 V--值。在映射中一个键对应一个值（键值对）。一个映射对应多个键值对来组成。
2. java中键要唯一，值可以任意。
3. Map不是集合。但是他是集合框架中的一员。--集合框架：集合、映射及操作集合的工具类或者映射所对应的类。
4. Map.Entry（Map接口的嵌套类）--代表键值对的类。每一个Entry都代表一个键值对--一个map对象有多对Entry对象组成。
5. Map的实现类
    1. HashMap：
        1. 基于哈希表Map接口的实现。
        2. 允许使用 null 值和 null 键
        3. 此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 （参考HashSet）
        4. 影响其性能：初始容量 和加载因子。容量 是哈希表中桶的数量。加载因子 是哈希表在其容量自动增加之前的一种警戒线。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。 通常，默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。 
        5. 线程不安全。
    2. HashTable：
        1. 基于哈希表Map接口的实现。默认初始值为11，加载因子为0.75f.
        2. 不允许使用null值
        3. 线程安全。
    3. TreeMap

public static void main(String[] args) {
    Map<String, Integer> map = new HashMap<>();
    // 添加键值对--不能保证添加顺序
    // 若键相同，则对应的值会被替换
    map.put("a", 1);
    map.put("b", 2);
    map.put("c", 3);
    map.put("a", 7);
    // 删除键值对
    // map.remove("b");
    // map.remove("adf");
    // 根据键获取值
    // System.out.println(map.get("a"));//7
    // 如果键不存在，则返回null
    // 返回值为null,键不存在？--不一定
    // System.out.println(map.get("ab"));//null
    // 清空映射
    // map.clear();{}
    // 判断是否包含指定的键
    // System.out.println(map.containsKey("a"));true
    // 判断是否包含指定的值
    // System.out.println(map.containsValue("a"));//false
    // 判断映射是否为空
    // System.out.println(map.isEmpty());
    // 获取映射的键值对个数
    // System.out.println(map.size());
    System.out.println(map);//{b=2, c=3, a=1}
}

public static void main(String[] args) {
    // 遍历映射
    Map<String, Integer> map = new HashMap<>();
    map.put("a", 1);
    map.put("b", 2);
    map.put("c", 3);
    map.put("a", 7);
    // 获取所有的键的集合--KeySet
    // 返回值类型为Set集合。
    Set<String> keys = map.keySet();
    for (String s : keys) {
        System.out.println(s+"="+map.get(s));
    }
    // 将映射中的所有键值对放入一个集合中进行遍历
    Set<Entry<String, Integer>> entries = map.entrySet();
//      for (Entry<String, Integer> entry : entries) {
//          System.out.println(entry);
//      }
//      Iterator<Entry<String, Integer>> it = entries.iterator();
//      while (it.hasNext()) {
//          Map.Entry<String, Integer> entry = it.next();
//          System.out.println(entry.getKey()+"="+entry.getValue());    
//      }
    for (Map.Entry<String, Integer> entry : map.entrySet()) {
        System.out.println(entry);
    }
    // HashMap中由键的哈希值来确定放到哪个桶中。
    // 允许使用null值和null键。
    // 默认初始值16 加载因子0.75f，每次扩展一倍。异步式线程不安全集合。
}

//java中最早的映射JDK1.0
// 不允许null作为键和值。
// 默认初始容量是11，加载因子0.75f。
// 同步式线程安全的映射
// 同步：一件事再同一时间内，仅能一个人来干。
// 异步：一件事再同一时间内，允许多个人来干。
// 在不考虑安全的前提下，优先HashMap。
// 在考虑安全的前提下，ConcurrentHashMap--异步式线程安全的映射。
public static void main(String[] args) {
    HashMap<Integer, Integer> map  = new HashMap<>();
    Scanner  s = new Scanner(System.in);
    List<Integer> keys = new ArrayList<>();
    int num = Integer.parseInt(s.nextLine());
    for (int i = 0; i < num; i++) {
        String str = s.nextLine();
        String[] strs = str.split(" ");
        Integer key = Integer.parseInt(strs[0]);
        Integer value = Integer.parseInt(strs[1]);
        if(map.containsKey(key)){
            map.put(key, value+map.get(key));
        }else{
            map.put(key, value);
        }
        keys.add(key);
    }
    System.out.println(map);
    Collections.sort(keys);
    for (Integer key : keys) {
        System.out.println(map.get(key));
    }
}

下一篇：
基础系列【十五】–Pattern