一. 继承体系

1. Map集合的特点

Map<K,V> : K: key, V: value

特点:

Map集合中的元素是键值对
Map集合的键是唯一的
一个键最多对应一个值

二.常用方法

1. 常用功能

(1) 增加方法

put(K key, V value)

HashMap<Integer, String> map = new HashMap<>();

map.put(3, "科比");
map.put(4, "詹姆斯");
map.put(5, "乔丹");
map.put(1, "贾巴尔");
map.put(2, "马龙");
  
System.out.println(map);


 注意事项: HashMap集合可以存储null键和null值

 Hashtable不能存储null键和null值

(2) 删除方法

remove(K key) : 根据传入的键, 删除整个键值对
```
// 删除
map.remove(2);
```

(3) 修改方法

put(K key, V value): 由于Map集合的键是唯一的, 所以如果添加了相同的键, 值会覆盖, 并且会将覆盖掉的值返回.

map.put(6, “马龙!!!”);

System.out.println(map.put(6, “张继科”)); // 马龙!!!

// 集合中的结果是 6=张继科

(4)查询功能

V get(K key) : 根据指定的键, 获取对应的值

// 创建Map集合 HashMap<Integer, String> map = new HashMap<>();

map.put(3, “科比”); map.put(4, “詹姆斯”); map.put(5, “乔丹”); map.put(1, “贾巴尔”); map.put(2, “马龙”);

System.out.println(map.get(1)); // 贾巴尔

2. 其他功能

size(): 获取集合中键值对的个数

int size = map.size(); System.out.println(size); // 5
containsKey(K key): 判断是否包含指定的键

System.out.println(map.containsKey(3)); // true System.out.println(map.containsKey(6)); // false
containsValue(V value): 判断是否包含指定的值

System.out.println(map.containsValue(“麦迪”)); // false System.out.println(map.containsValue(“科比”)); // true
Collection values() : 获取存放所有值的集合

HashMap<Integer, String> map = new HashMap<>();

map.put(3, “科比”); map.put(4, “詹姆斯”); map.put(5, “乔丹”); map.put(1, “贾巴尔”); map.put(2, “马龙”);

Collection values = map.values();

System.out.println(values); System.out.println(map);

// ==============输出==================== [贾巴尔, 马龙, 科比, 詹姆斯, 乔丹] {1=贾巴尔, 2=马龙, 3=科比, 4=詹姆斯, 5=乔丹}

#三. 遍历

以前的集合遍历:

list: 有索引, 可以使用普通for循环, 也可以使用增强for循环
Set: 没有索引, 由于是Collection的子接口所有有迭代器, 可以使用增强for循环

Map集合的遍历

Map没有索引, 不能使用普通for; 跟Collection没有关系, 没有迭代器, 不能使用增强for循环; 不能直接遍历. 需要间接的进行遍历

1. Map集合的第一种遍历方式: 键找值

Set keySet(): 获取Map集合中所有键的Set集合

 public class Demo01_第一种方式 {   public static void main(String[] args) {
  HashMap<String, String> map = new HashMap<>();
  map.put("赵丽颖", "冯绍峰");
  map.put("高圆圆", "赵又廷");
  map.put("贾静雯", "修杰楷");
  map.put("袁咏仪", "张智霖");
  map.put("包文婧", "包贝尔");

  // 获取Map集合中所有键的集合
  Set<String> keySet = map.keySet();
  // 遍历所有键的集合, 获取到每一个键
  for (String key : keySet) {
      // 通过键获取值
      String value = map.get(key);
      System.out.println(key + "=" + value);
  }

} }

2. Map集合的第二种遍历方式: 键值对

键值对类型: Map.Entry<K, V>
Set<Map.Entry<K, V» entrySet() : 获取Set集合, Set集合中的元素是 “键值对” 类型
查看”键值对” 中有什么方法

K getKey(): 获取键值对中的键 V getValue(): 获取键值对中的值

 public class Demo02_第二种方式 {
   public static void main(String[] args) {
    HashMap<String, String> map = new HashMap<>();
    map.put("赵丽颖", "冯绍峰");
    map.put("高圆圆", "赵又廷");
    map.put("贾静雯", "修杰楷");
    map.put("袁咏仪", "张智霖");
    map.put("包文婧", "包贝尔");
    // 获取Map集合中所有 键值对 的集合
    // 键值对:  Map.Entry<K, V>
    Set<Map.Entry<String, String>> entrySet = map.entrySet();

    // 遍历Set集合获取的每一个元素, 是 "键值对" 类型
    for (Map.Entry<String, String> entry : entrySet) {
        // 获取键和值
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + "=" + value);
     }
   }
}

四. 其他内容

1. HashMap集合中存储自定义类型

HashSet: 想保证元素的唯一, 需要重写hashCode(), equals()

2. LinkedHashMap

LinkedHashSet: 元素唯一, 有序
LinkedHashMap: 键是唯一的, 有序

3. jdk9集合添加方法

// 每一个集合接口中都有一个静态方法: of(多个元素)

牛刀小试(斗地主的牌)

package com.it._05poker;

import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.TreeSet;

public class Demo01_斗地主 { public static void main(String[] args) { // 创建Map集合, 集合的键是1~54 , 值按照扑克顺序排序 HashMap<Integer, String> map = new HashMap<>(); // 创建List集合, 元素就是map集合的键 ArrayList list = new ArrayList<>(); // 点数数组 String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"}; // 花色数组 String[] colors = {"♦", "♣", "♥", "♠"}; // 创建变量用来当做map集合的键 int count = 1; // 循环嵌套添加 // 先遍历点数 for (String number : numbers) { // 再遍历花色 for (String color : colors) { String poker = color + number; // 添加 map.put(count, poker); list.add(count++); } } // 大小王 map.put(count, "♙"); list.add(count++); map.put(count,"♛"); list.add(count);

    // System.out.println(map);
    // System.out.println(list);


    // 洗牌
    Collections.shuffle(list);

    // 创建四个容器
    ArrayList<Integer> me = new ArrayList<>();
    ArrayList<Integer> faBro = new ArrayList<>();
    ArrayList<Integer> dragonFive = new ArrayList<>();
    ArrayList<Integer> left = new ArrayList<>();

    // 使用普通for循环遍历list集合
    for (int i = 0; i < list.size(); i++) {
        if (i >= list.size() - 3) {
            left.add(list.get(i));
        }else if (i % 3 == 0) {
            me.add(list.get(i));
        }else if (i % 3 == 1) {
            faBro.add(list.get(i));
        }else{
            dragonFive.add(list.get(i));
        }
    }

    // 排序
    Collections.sort(me);
    Collections.sort(faBro);
    Collections.sort(dragonFive);
    Collections.sort(left);

    // 看牌
    show(map, left, "底牌");
    show(map, me, "泽神");
    show(map, faBro, "小进");
    show(map, dragonFive, "大龙");

}

/**
 * 此方法用于看牌
 */
public static void show(HashMap<Integer, String> map, ArrayList<Integer> list, String name) {
    StringBuilder sb = new StringBuilder(name);
    sb.append(": ");
    // 遍历List集合
    for (Integer key : list) {
        // 根据键获取值
        String value = map.get(key);
        sb.append(value).append(" ");
    }
    System.out.println(sb);
} }

Map ChenYuan