本帖最后由 849618121 于 2018-11-26 15:03 编辑
Map双列集合
特点
常用方法
2种遍历方式
自定义对象作为 key(键) value(值)
HashMap, LinkedHashMap, Hashtable
JDK9 快速创建集合
IDEA Debug调试功能
斗地主发牌(排序版)
Map体系
Map集合概述知识点
Map双列集合有什么特点
Map集合适合存储什么样的数据
总结:
java.util.Map<K, V>接口Map集合特点:
1. 是双列集合, 一个元素包含两个值 (键key, 值value) 键值对
2. key和value的类型可以相同, 也可以不同
3. key不允许重复, value可以重复
4. key和value是一一对应的, 一个键只能对应一个值Map集合适合存储"一对一关系"的数据
夫妻
String : Phone
统计次数: 某个字符出现了多少次 "aaababababba"
'a': 1
'b': 3
补充:
public class Node<K, V> {
K key;
V value;
}
Map常用子类知识点
Map接口有哪些常用实现类
HashMap类有什么特点
总结:
java.util.Map<K, V>接口: 双列集合的根接口, 规定了共性的方法
|
|_ HashMap<K, V>类: 底层哈希表. key存取无序不可重复
|_ LinkedHashMap<K, V>类: 底层哈希表+链表. key存取有序不可重复
映射: 键和值的对应关系 mappingHashSet底层使用的就是HashMap
LinkedHashSet底层使用的就是LinkedHashMap
补充: Map中常用方法知识点
Map接口中定义的共性方法有哪些
如何添加键值对
总结:
java.util.Map接口: 双列集合的顶层
// 成员方法
V put(K key, V value): 添加/修改 键值对.
如果键存在, 则用新值替换已有值, 返回被替换的值; 如果键不存在, 添加键值对, 返回null
V remove(Object key): 根据键删除键值对, 返回被删除元素的值
如果键不存在, 返回null
V get(Object key): 根据键获取值.
如果键不存在, 则返回null
boolean containsKey(Object key): 判断是否包含指定的键
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的Entry对象的集合(Set集合)
补充:
entry 节点
public class Entry<K,V> { // 键值对 对象
K key;
V value;
}
5分钟练习: 测试Map常用方法
需求:
创建HashMap对象, 存储键值对都是String, 存储以下键值对
黄晓明, 杨颖
文章, 马伊琍
邓超, 孙俪
删除文章马伊琍
获取邓超的老婆打印出来
判断键中是否有黄晓明
代码:
public class Test {
public static void main(String[] args) {
// 创建Map集合, 用多态也行, 不用多态也行
// 注意泛型有2个, 左边是键的类型, 右边是值的类型
Map<String, String> map = new HashMap<>(); // 添加夫妻对
map.put("黄晓明", "杨颖");
map.put("文章", "马伊琍");
map.put("邓超", "孙俪");
System.out.println(map); // {邓超=孙俪, 文章=马伊琍, 黄晓明=杨颖}
// key 存取无序, 不可重复
// 删除文章马伊琍
String removedValue = map.remove("文章");
System.out.println("删除文章返回的值:" + removedValue); // 删除文章返回的值:马伊琍
System.out.println(map); // {邓超=孙俪, 黄晓明=杨颖} // 获取邓超的老婆打印出来
String value = map.get("邓超");
System.out.println("通过邓超获取的值:" + value); // 通过邓超获取的值:孙俪
System.out.println(map); // {邓超=孙俪, 黄晓明=杨颖} // 判断键中是否有黄晓明
boolean b = map.containsKey("黄晓明");
System.out.println("是否包含黄晓明这个key:" + b); // 是否包含黄晓明这个key:true
}
}
Map遍历方式一: keySet()方法实现通过键找值知识点
如何利用 keySet() 方法实现Map的遍历
总结:
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
keySet()遍历步骤:
1. Map对象调用 keySet() 方法, 获取包含所有key的Set集合
2. 遍历Set集合, 获取每个key
3. 通过Map对象调用 get(Object key) 方法根据key获取到value
Map<String, String> map = new HashMap<>();
// keySet()遍历
Set<String> keys = map.keySet();
for (String key : keys) {
// 通过每个键获取值
String value = map.get(key);
// 打印当前键值对
System.out.println(key + "=" + value);
}
补充: 5分钟练习: keySet()遍历Map
需求:
创建HashMap集合, 存储以下键值对
"赵丽颖", 168
"杨颖", 165
"林志玲", 178
使用keySet()方式遍历Map, 打印键值对, 效果:
林志玲=178
赵丽颖=168
杨颖=165
代码:
public class Test {
public static void main(String[] args) {
// 创建Map集合
HashMap<String, Integer> map = new HashMap<>(); // 添加键值对
map.put("赵丽颖", 168);
map.put("杨颖", 165);
map.put("林志玲", 178); // 通过keySet()先获取包含所有key的set集合
Set<String> keySet = map.keySet();
// 遍历set集合, 获取每个key
for (String key : keySet) {
// 通过key获取value
Integer value = map.get(key);
// 打印键值对
System.out.println(key + "=" + value);
} System.out.println("-------------------"); // 简化的增强for循环
for (String key : map.keySet()) {
// 通过key获取value
Integer value = map.get(key);
// 打印键值对
System.out.println(key + "=" + value);
} System.out.println("-------------------"); // 迭代器
Iterator<String> iterator = keySet.iterator();
while (iterator.hasNext()) {
String key = iterator.next();
Integer value = map.get(key);
System.out.println(key + "=" + value);
}
}
}
Entry键值对对象介绍知识点
Map中的存储的 键值对 和 Entry对象 有什么关系
总结:
java.util.Map.Entry接口:
// 常用成员方法
K getKey(): 获取Entry对象中的键
V getValue(): 获取Entry对象中的值
Entry对象就是一个节点, 节点中存储了key和value
拿到一个Entry对象就可以从中获取key和value
// HashMap中Entry实现类
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next; public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
}java.util.Map接口
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)
补充: Map遍历方式2: 通过entrySet()获取Entry对象形式遍历知识点
如何利用Map的 entrySet() 方法进行遍历
总结:
java.util.Map接口
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)
entrySet()方法遍历Map步骤:
1. Map对象调用 entrySet() 获取包含所有Entry对象的Set集合
2. 遍历Set集合, 获取每个Entry对象
3. 调用Entry对象的 getKey() 和 getValue() 方法获取键和值
Map<String, String> map = new HashMap<>();
// keySet()遍历
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
// 通过Entry对象获取每个键值对
String value = entry.getKey();
String value = entry.getValue();
// 打印当前键值对
System.out.println(key + "=" + value);
}
补充: 5分钟练习: entrySet()遍历Map
需求:
创建HashMap集合, 存储以下键值对
"赵丽颖", 168
"杨颖", 165
"林志玲", 178
使用entrySet()方式遍历Map, 打印键值对, 效果:
赵丽颖=168
杨颖=165
林志玲=178
代码:
public class Test { public static void main(String[] args) {
// 创建Map集合
HashMap<String, Integer> map = new HashMap<>(); // 添加键值对
map.put("赵丽颖", 168);
map.put("杨颖", 165);
map.put("林志玲", 178); // 使用entrySet遍历
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
// 遍历包含所有entry对象的set集合, 取出每个entry对象
for (Map.Entry<String, Integer> entry : entrySet) {
// 通过entry对象分别获取key和value
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "=" + value);
} System.out.println("-----------------"); // 简化的增强for
for (Map.Entry<String, Integer> entry : map.entrySet()) { // map.entrySet().for 回车
// 通过entry对象分别获取key和value
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "=" + value);
} System.out.println("-----------------"); // 迭代器
Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
// 通过entry对象分别获取key和value
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
HashMap存储自定义数据类型作为键知识点
HashMap存储自定义JavaBean对象作为key, 如何保证key唯一不重复
总结:
HashMap存储自定义JavaBean对象作为key保证key唯一不重复, 需要让JavaBean重写 hashCode() 和 equals() 方法
补充: 5分钟练习: 使用自定义JavaBean作为key
需求:
定义Person类:
私有成员变量: 姓名String name, 年龄int age
生成无参/有参构造, set/get方法, toString, hashCode(), equals()
定义测试类:
创建4个Person对象, 分别如下:
"女王", 18
"秦始皇", 18
"普京", 30
"女王", 18
创建HashMap集合, 存入键为4个Person对象, 值为对应国家字符串: 英国, 秦国, 俄罗斯, 毛里求斯
使用entrySet()方法遍历Map集合, 输出键值对
代码:
public class Test {
public static void main(String[] args) {
// 创建4个Person对象
Person p1 = new Person("女王", 18);
Person p2 = new Person("秦始皇", 18);
Person p3 = new Person("普京", 30);
Person p4 = new Person("女王", 18);
// 创建HashMap集合
HashMap<Person, String> map = new HashMap<>(); map.put(p1, "英国");
map.put(p2, "秦国");
map.put(p3, "俄罗斯");
map.put(p4, "毛里求斯"); // 遍历
Set<Map.Entry<Person, String>> entrySet = map.entrySet();
for (Map.Entry<Person, String> entry : entrySet) {
// 通过entry对象获取key和value
Person key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "-->" + value);
}
}
}
LinkedHashMap类知识点
LinkedHashMap底层使用什么数据结构, 有什么特点
总结:
LinkedHashMap底层: 哈希表 + 链表
key不允许重复, 但key存取有序
补充: Hashtable类知识点
Hashtable和HashMap有什么相同点和不同点
总结:
Hashtable和HashMap:
相同点:
1. 底层都是哈希表
不同点:
1. Hashtable不允许存储 null 值和 null 键; HashMap允许存储 null 值和 null 键
2. Hashtable线程安全效率低; HashMap线程不安全效率高
Hashtable目前很少使用.
但其子类 Properties 集合, 可以与IO流结合使用, 应用较多
补充: Map集合练习
5分钟练习: 利用Map计算字符串中每个字符出现的次数
需求: 键盘录入一个字符串, 计算一个字符串中每个字符出现次数"aaabbbbccc"a:2
b:4
c:3分析:
1.使用Scanner获取用户输入的字符串
2.创建Map集合,key是字符串中的字符,value是字符的个数
3.遍历字符串,获取每一个字符
4.使用获取到的字符,去Map集合判断key是否存在 containsKey()
key存在:
通过字符(key),获取value(字符个数)
value++
put(key,value)把新的value存储到Map集合中
key不存在:
put(key,1)
5.遍历Map集合,输出结果
代码:
public class Test {
public static void main(String[] args) {
// 键盘录入
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String s = scanner.next(); // 创建Map集合
// Map<Character, Integer> map = new HashMap<>();
Map<Character, Integer> map = new TreeMap<>(); // TreeMap // 将字符串转换为char[]
char[] arr = s.toCharArray();
// 遍历字符数组中的字符
for (char c : arr) {
// 先判断该字符是否在map中存储过
if (map.containsKey(c)) {
// 包含该key, 则需要取出value的次数, 增加1, 再存回去
Integer count = map.get(c);
count++;
map.put(c, count);
} else {
// 不包含该key, 则认为是第一次遇到, 次数为1次
map.put(c, 1);
}
} // 遍历map查看
for (Map.Entry<Character, Integer> entry : map.entrySet()) {
Character ch = entry.getKey();
Integer count = entry.getValue();
System.out.println(ch + "=" + count);
}
}
}
JDK9对集合添加的优化知识点
JDK 9 中新增的快速添加多个元素的方法如何使用
有什么注意事项
总结:
使用集合添加大量元素时, 反复add(...)比较麻烦. JDK 9 为集合提供了一些静态方法, 可以方便的对集合进行初始化java.util.List接口:
// 静态方法
static List<E> of(E... e): 返回包含指定元素的 不可变List 集合
java.util.Set接口:
// 静态方法
static Set<E> of(E... e): 返回包含指定元素的 不可变Set 集合
java.util.Map接口:
// 静态方法
static Map<K, V> of(K k1, V v1, ...): 返回包含指定键值对的 不可变Map 集合
注意事项:
1. of() 方法只适用于List接口, Set接口, Map接口, 不适用于接口的实现类
2. of() 方法的返回值是一个不可变的集合, 集合不能再使用 add(), put() 方法添加元素, 会抛出异常
3. Set接口和Map接口在调用 of() 方法的时候, 不能有重复的元素, 否则会抛出异常
补充:
将 不可变集合 的元素转移到常见集合实现类中:
// List
ArrayList<Integer> list = new ArrayList<>(List.of(1,2,3)); // Set
HashSet<Integer> set = new HashSet<>(Set.of(1,2,3)); // Map
HashMap<Integer, String> map = new HashMap<>(Map.of(1,"a",2,"b")); 5分钟练习: 使用of方法快速添加元素
需求:
使用List.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
使用Set.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
使用Map.of()方法, 添加"a":1, "b":2, "c":3, 获取集合对象, 使用entrySet()遍历打印输出
代码:
public class Test {
public static void main(String[] args) {
// 使用List.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
List<Integer> list = List.of(1, 2, 3); // 得到是不可变集合, 只能获取元素, 不能添加
for (Integer i : list) {
System.out.println(i);
} // 使用有参的ArrayList构造方法, 将不可变集合转换为可变集合
ArrayList<Integer> arrayList = new ArrayList<>(list);
arrayList.add(4);
arrayList.add(5);
System.out.println(arrayList); System.out.println("-----------------"); // 使用Set.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
Set<Integer> set = Set.of(1, 2, 3);
for (Integer i : set) {
System.out.println(i);
} System.out.println("-----------------"); Map<String, Integer> map = Map.of("a", 1, "b", 2, "c", 3);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
Debug调试模式介绍知识点
Debug调试有什么作用
如何Debug
如何添加断点
如何删除断点
如何在debug模式下运行
总结:
断点:
breakpoint, 在debug模式下, 程序运行到断点会暂停住, 便于我们在程序运行过程中查看
Debug调试程序:
可以让代码逐行执行,查看代码执行的过程,调试程序中出现的bug
使用方式:
在行号的右边,鼠标左键单击,添加断点(每个方法的第一行,哪里有bug添加到哪里)
右键,选择Debug执行程序
程序就会停留在添加的第一个断点处
执行程序:
f8:逐行执行程序
f7:进入到方法中
shift+f8:跳出方法
f9:跳到下一个断点,如果没有下一个断点,那么就结束程序
ctrl+f2:退出debug模式,停止程序
Console:切换到控制台
补充: 斗地主发牌案例
有(大小)序斗地主: 需求分析
需求: 实现斗地主发牌, 特殊要求是看牌时按照从小到大顺序排列
分析:
准备牌:
为了牌有大小顺序, 给牌编号, 一个编号对应一张牌: 0=大王, 1=小王, 2=♤2, 3=♤3 ...
编号和牌是一对一映射关系, 用HashMap<Integer, String>存储, key为编号, value为牌
再为编号单独创建一个额外的ArrayList<Integer> pokerIndex
定义编号变量 int index = 0;
按照编号添加大小王
嵌套for循环拼接序号和花色, 存入HashMap, 同时将编号存入ArrayList, 编号index++
洗牌:
Collections.shuffle(List list)将编号的ArrayList pokerIndex打乱顺序
发牌:
创建4个ArrayList, 前3个是玩家, 最后一个是底牌
遍历编号的ArrayList pokerIndex, 发编号给玩家, >=51时发给底牌
对4个ArrayList排序
看牌
定义方法:
public static void lookPoker(String name, HashMap<Integer, String> poker, ArrayList<Integer> list)
方法内打印姓名, 遍历编号集合ArrayList<Integer> list获取每个编号, 通过编号从HashMap<Integer,String> poker中获取牌, 打印
调用方法传入 玩家姓名, 牌的Map集合, 玩家集合 来看牌 斗地主案例之发牌看牌代码编写
10分钟练习: 实现斗地主代码:
public class Test {
public static void main(String[] args) {
/*
准备牌
*/
// 定义花色和数值集合
List<String> colors = List.of("♤", "♡", "♣", "♢");
List<String> numbers = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
// 定义牌盒map
HashMap<Integer, String> poker = new HashMap<>();
// 定义牌的序号集合list
ArrayList<Integer> pokerIndex = new ArrayList<>(); // 定义一个索引作为牌的序号
int index = 0;
// 先添加大小王
poker.put(index, "大王");
pokerIndex.add(index);
index++;
poker.put(index, "大王");
pokerIndex.add(index);
index++; // 然后拼接牌, 并添加
for (String number : numbers) {
for (String color : colors) {
String pai = color + number;
// 添加到牌盒
poker.put(index, pai);
// 添加索引
pokerIndex.add(index);
// 增加索引
index++;
}
} /*
洗牌
*/
Collections.shuffle(pokerIndex); /*
发牌
*/
// 创建玩家和底牌集合, 存储序号
ArrayList<Integer> player01 = new ArrayList<>();
ArrayList<Integer> player02 = new ArrayList<>();
ArrayList<Integer> player03 = new ArrayList<>();
ArrayList<Integer> diPai = new ArrayList<>();
// 遍历序号集合, 发序号
for (int i = 0; i < pokerIndex.size(); i++) {
//取出一个序号
Integer in = pokerIndex.get(i);
// 发
if (i >= 51) {
diPai.add(in);
} else if (i % 3 == 0) {
player01.add(in);
} else if (i % 3 == 1) {
player02.add(in);
} else if (i % 3 == 2) {
player03.add(in);
}
} /*
排序
*/
Collections.sort(player01);
Collections.sort(player02);
Collections.sort(player03);
Collections.sort(diPai);
/*
看牌
*/
lookPoker("刘备", poker, player01);
lookPoker("关羽", poker, player02);
lookPoker("张飞", poker, player03);
lookPoker("底牌", poker, diPai);
} // 定义一个方法来看牌
private static void lookPoker(String name, HashMap<Integer, String> poker, ArrayList<Integer> list) {
// 先打印玩家名称
System.out.print(name + ":");
// 然后遍历序号集合, 通过序号获取map中的牌
for (Integer key : list) {
String pai = poker.get(key);
// 打印牌
System.out.print(pai + " ");
}
// 打印完一个玩家的牌后换行
System.out.println();
}
}
今日API
java.util.Map接口: 双列集合的顶层
// 成员方法
V put(K key, V value): 添加/修改 键值对.
如果键存在, 则用新值替换已有值, 返回被替换的值; 如果键不存在, 则添加键值对, 返回null
V remove(Object key): 根据键删除键值对, 返回被删除元素的值
如果键不存在, 返回null
V get(Object key): 根据键获取值.
如果键不存在, 则返回null
boolean containsKey(Object key): 判断是否包含指定的键
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)
// JDK 9对于集合初始化的优化
java.util.List
// 静态方法
static List<E> of(E... e): 返回包含指定元素的 不可变List 集合
java.util.Set
// 静态方法
static Set<E> of(E... e): 返回包含指定元素的 不可变Set 集合
java.util.Map
// 静态方法
static Map<K, V> of(K k1, V v1): 返回包含指定键值对的 不可变Map 集合
Map双列集合总结
Map接口: 双列集合的根接口, 规定了共性的方法
|_ HashMap类: 哈希表=数组+链表+红黑树. key无序不可重复, 可存null键null值, 线程不安全效率高
| |_ LinkedHashMap类: 哈希表+链表. 哈希表实现key不可重复, 链表实现key存取有序
|
|_ Hashtable类: 哈希表. Hash特性针对key, key无序不可重复, 不可存null键null值, 线程安全效率低
|_ TreeMap类: 红黑树结构(存入时就排序). Tree特性针对key, 可以按照key排序, 要求key具备比较性
|_ 遍历
|_ keySet(): 获取所有key组成的Set集合, 遍历Set集合拿到key, 通过Map的get(key)得到value
| |_ 对于Set<Key>的遍历
| |_ 增强for
| |_ 迭代器
|_ entrySet(): 获取所有的key和value组成的Entry对象的Set集合, 遍历出entry对象, 通过
entry对象的getKey()获取对应的key, 通过Entry对象的getValue方法获取对应的value
|_ 对Set<Entry>的遍历
|_ toArray()
|_ 增强for
|_ 迭代器
Map集合特点
1. 一个元素有一个key+一个value
2. key value的类型可以一样, 可以不一样
3. key不能重复
4. 一个key对应一个value
HashMap
key 存取无序
能存null值或null键
LinkedHashMap
key 存取有序
使用Map集合添加方法保存数据
V put(K k, V v)
如果key不存在, 则添加键值对, 返回null
如果key存在, 则替换旧值, 返回旧值
使用”键找值”的方式遍历Map集合
keySet()
Set<键> set = map.keySet();
for (键类型 key: set) {
值 = map.get(key);
}
使用”键值对”的方式遍历Map集合
entrySet()
Set<Map.Entry<键, 值>> set = map.entrySet();
for (Map.Entry<键, 值> entry : set) {
entry.getKey();
entry.getValue();
}
能够使用HashMap存储自定义键值对的数据
自定义JavaBean
作key: 重写hashCode() equals()
作value: 没有要求
|
|
收藏
淘帖
踩
