共计 5566 个字符，预计需要花费 14 分钟才能阅读完成。
一、Map 汇合概述和特点
Map 接口概述
查看 API 能够晓得：
将键映射到值的对象
一个映射不能蕴含反复的键
每个键最多只能映射到一个值
Map 接口和 Collection 接口的不同
Map 是双列的,Collection 是单列的
Map 的键惟一,Collection 的子体系 Set 是惟一的
Map 汇合的数据结构值针对键无效，跟值无关;Collection 汇合的数据结构是针对元素无效
二、Map 汇合的性能概述
Map 汇合的性能概述
增加性能
V put(K key,V value): 增加元素。
如果键是第一次存储，就间接存储元素，返回 null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
删除性能
void clear(): 移除所有的键值对元素
V remove(Object key)：依据键删除键值对元素，并把值返回
判断性能
boolean containsKey(Object key)：判断汇合是否蕴含指定的键
boolean containsValue(Object value): 判断汇合是否蕴含指定的值
boolean isEmpty()：判断汇合是否为空
获取性能
Set<Map.Entry<K,V>> entrySet():
V get(Object key): 依据键获取值
Set<K> keySet(): 获取汇合中所有键的汇合
Collection<V> values(): 获取汇合中所有值的汇合
长度性能
int size()：返回汇合中的键值对的个数
三、Map 汇合的遍历之键找值
键找值思路：
获取所有键的汇合
遍历键的汇合，获取到每一个键
依据键找值
案例演示
Map 汇合的遍历之键找值
HashMap<String, Integer> hm = new HashMap<>();
hm.put(“ 张三 ”, 23);
hm.put(“ 李四 ”, 24);
hm.put(“ 王五 ”, 25);
hm.put(“ 赵六 ”, 26);
/*Set<String> keySet = hm.keySet(); // 获取汇合中所有的键
Iterator<String> it = keySet.iterator(); // 获取迭代器
while(it.hasNext()) {// 判断单列汇合中是否有元素
String key = it.next(); // 获取汇合中的每一个元素, 其实就是双列汇合中的键
Integer value = hm.get(key); // 依据键获取值
System.out.println(key + “=” + value); // 打印键值对
}*/
for(String key : hm.keySet()) {// 加强 for 循环迭代双列汇合第一种形式
System.out.println(key + “=” + hm.get(key));
}
四、Map 汇合的遍历之键值对对象找键和值
键值对对象找键和值思路：
获取所有键值对对象的汇合
遍历键值对对象的汇合，获取到每一个键值对对象
依据键值对对象找键和值
案例演示
Map 汇合的遍历之键值对对象找键和值
HashMap<String, Integer> hm = new HashMap<>();
hm.put(“ 张三 ”, 23);
hm.put(“ 李四 ”, 24);
hm.put(“ 王五 ”, 25);
hm.put(“ 赵六 ”, 26);
/*Set<Map.Entry<String, Integer>> entrySet = hm.entrySet(); // 获取所有的键值对象的汇合
Iterator<Entry<String, Integer>> it = entrySet.iterator();// 获取迭代器
while(it.hasNext()) {
Entry<String, Integer> en = it.next(); // 获取键值对对象
String key = en.getKey(); // 依据键值对对象获取键
Integer value = en.getValue(); // 依据键值对对象获取值
System.out.println(key + “=” + value);
}*/
for(Entry<String,Integer> en : hm.entrySet()) {
System.out.println(en.getKey() + “=” + en.getValue());
}
五、统计字符串中每个字符呈现的次数
案例演示
需要：统计字符串中每个字符呈现的次数
String str = “aaaabbbcccccccccc”;
char[] arr = str.toCharArray(); // 将字符串转换成字符数组
HashMap<Character, Integer> hm = new HashMap<>(); // 创立双列汇合存储键和值
for(char c : arr) {// 遍历字符数组
/*if(!hm.containsKey(c)) {// 如果不蕴含这个键
hm.put(c, 1); // 就将键和值为 1 增加
}else {// 如果蕴含这个键
hm.put(c, hm.get(c) + 1); // 就将键和值再加 1 增加进来
}
//hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
Integer i = !hm.containsKey(c) ? hm.put(c, 1) : hm.put(c, hm.get(c) + 1);
}
for (Character key : hm.keySet()) {// 遍历双列汇合
System.out.println(key + “=” + hm.get(key));
}
六、HashMap 和 Hashtable 的区别
面试题
HashMap 和 Hashtable 的区别
Hashtable 是 JDK1.0 版本呈现的, 是线程平安的, 效率低,HashMap 是 JDK1.2 版本呈现的, 是线程不平安的, 效率高
Hashtable 不能够存储 null 键和 null 值,HashMap 能够存储 null 键和 null 值
七、Collections 工具类的概述和常见办法解说
Collections 类概述
针对汇合操作 的工具类
Collections 成员办法
public static <T> void sort(List<T> list)
public static <T> int binarySearch(List<?> list,T key)
public static <T> T max(Collection<?> coll)
public static void reverse(List<?> list)
public static void shuffle(List<?> list)
八、模仿斗地主洗牌和发牌
案例演示
模仿斗地主洗牌和发牌，牌没有排序
// 买一副扑克
String[] num = {“A”,”2″,”3″,”4″,”5″,”6″,”7″,”8″,”9″,”10″,”J”,”Q”,”K”};
String[] color = {“ 方片 ”,” 梅花 ”,” 红桃 ”,” 黑桃 ”};
ArrayList<String> poker = new ArrayList<>();
for(String s1 : color) {
for(String s2 : num) {
poker.add(s1.concat(s2));
}
}
poker.add(“ 小王 ”);
poker.add(“ 大王 ”);
// 洗牌
Collections.shuffle(poker);
// 发牌
ArrayList<String> gaojin = new ArrayList<>();
ArrayList<String> longwu = new ArrayList<>();
ArrayList<String> me = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>();
for(int i = 0; i < poker.size(); i++) {
if(i >= poker.size() – 3) {
dipai.add(poker.get(i));
}else if(i % 3 == 0) {
gaojin.add(poker.get(i));
}else if(i % 3 == 1) {
longwu.add(poker.get(i));
}else {
me.add(poker.get(i));
}
}
// 看牌
System.out.println(gaojin);
System.out.println(longwu);
System.out.println(me);
System.out.println(dipai);
九、模仿斗地主洗牌和发牌并对牌进行排序的代码实现
案例演示
模仿斗地主洗牌和发牌并对牌进行排序的代码实现
// 买一副牌
String[] num = {“3″,”4″,”5″,”6″,”7″,”8″,”9″,”10″,”J”,”Q”,”K”,”A”,”2″};
String[] color = {“ 方片 ”,” 梅花 ”,” 红桃 ”,” 黑桃 ”};
HashMap<Integer, String> hm = new HashMap<>(); // 存储索引和扑克牌
ArrayList<Integer> list = new ArrayList<>(); // 存储索引
int index = 0; // 索引的开始值
for(String s1 : num) {
for(String s2 : color) {
hm.put(index, s2.concat(s1)); // 将索引和扑克牌增加到 HashMap 中
list.add(index); // 将索引增加到 ArrayList 汇合中
index++;
}
}
hm.put(index, “ 小王 ”);
list.add(index);
index++;
hm.put(index, “ 大王 ”);
list.add(index);
// 洗牌
Collections.shuffle(list);
// 发牌
TreeSet<Integer> gaojin = new TreeSet<>();
TreeSet<Integer> longwu = new TreeSet<>();
TreeSet<Integer> me = new TreeSet<>();
TreeSet<Integer> dipai = new TreeSet<>();
for(int i = 0; i < list.size(); i++) {
if(i >= list.size() – 3) {
dipai.add(list.get(i)); // 将 list 汇合中的索引增加到 TreeSet 汇合中会主动排序
}else if(i % 3 == 0) {
gaojin.add(list.get(i));
}else if(i % 3 == 1) {
longwu.add(list.get(i));
}else {
me.add(list.get(i));
}
}
// 看牌
lookPoker(“ 高进 ”, gaojin, hm);
lookPoker(“ 龙五 ”, longwu, hm);
lookPoker(“ 冯佳 ”, me, hm);
lookPoker(“ 底牌 ”, dipai, hm);
}
public static void lookPoker(String name,TreeSet<Integer> ts,HashMap<Integer, String> hm) {
System.out.print(name + “ 的牌是:”);
for (Integer index : ts) {
System.out.print(hm.get(index) + ” “);
}
System.out.println();
}