南哥带你玩转 Java 之 Java Map 接口

Map 接口

Map 接口(双列集合的根接口)
1.以键值对形式保存数据
2.键和值一一映射,可以通过键来获取值

注意:
给定一个键和一个值，你可以将该值存储在一个Map对象. 之后，你可以通过键来访问对应的值。
当访问的值不存在的时候，方法就会抛出一个NoSuchElementException异常.
当对象的类型和Map里元素类型不兼容的时候，就会抛出一个 ClassCastException异常。
当在不允许使用Null对象的Map中使用Null对象，会抛出一个NullPointerException 异常。
当尝试修改一个只读的Map时，会抛出一个UnsupportedOperationException异常。

map 的添加方法
HashMap<String,Integer> map = new HashMap<>();
Integer i1 = map.put("甲", 30);
Integer i2 = map.put("乙", 40);
Integer i3 = map.put("丙", 20);
System.out.println(map);                // {甲=30, 乙=40, 丙=20}
Integer i4 = map.put("丙", 80);
// Integer 返回的是被覆盖的值,没被覆盖时,返回 null
System.out.println(i1);                 // null
System.out.println(i2);                 // null
System.out.println(i3);                 // null
System.out.println(i4);                 // 20
System.out.println(map);                // {甲=30, 乙=40, 丙=80}

Map 基本方法

HashMap<String, Integer> map = new HashMap<>();
map.put("甲", 30);
map.put("乙", 20);
map.put("丙", 20);

// 是否包含 key
boolean containsKey = map.containsKey("甲");
System.out.println(containsKey);        // true

// 是否包含 value
boolean containsValue = map.containsValue(20);
System.out.println(containsValue);      // true

// 通过 key 获取对应 value
Integer integer1 = map.get("甲");
Integer integer2 = map.get("丁");
System.out.println(integer1);           // 30
System.out.println(integer2);           // null

// 获取所有 key 的 Set 集合
Set<String> keySet = map.keySet();
System.out.println(keySet);             // [甲, 乙, 丙]

// 获取所有 value 的集合
Collection<Integer> values = map.values();
System.out.println(values);             // [30, 20, 20]

// 通过 key 删除整个键值对
Integer remove = map.remove("乙");
Integer remove2 = map.remove("丁");
System.out.println(remove);             // 20
System.out.println(remove2);            // null

// 清空 map
map.clear();
System.out.println(map);                // {}

Student 类:
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "[ 姓名 : " + name + " , 年龄 : " + age + " ]";
}

@Override
public int compareTo(Student o) {
int num = this.age - o.getAge();
return num == 0 ? 1 : num;
}

}

// 创建一个 map , key 保存学生, value 保存户籍
HashMap<Student, String> map = new HashMap<>();
map.put(new Student("鹏", 21), "安徽");
map.put(new Student("北", 22), "河南");
map.put(new Student("轩", 23), "江苏");
// 去重(重写 hashCode 和 equals 方法)
// 重写之后,key 相同, value 会被新值覆盖
map.put(new Student("北", 22), "河北");
System.out.println(map);            // {[ 姓名 : 北 , 年龄 : 22 ]=河北, [ 姓名 : 轩 , 年龄 : 23 ]=江苏, [ 姓名 : 鹏 , 年龄 : 21 ]=安徽}

遍历 Map

迭代器遍历
HashMap<String, Integer> map = new HashMap<>();
map.put("甲", 30);
map.put("乙", 40);
map.put("丙", 20);
map.put("丁", 20);
// 通过 keySet 遍历
// 取出所有 key 的 Set 集合
Set<String> keySet = map.keySet();
// 获取迭代器
Iterator<String> iterator = keySet.iterator();
// 遍历所有 key
while (iterator.hasNext()) {
String key = iterator.next();
// 通过 key 获取对应 vlaue
Integer integer = map.get(key);
System.out.println("[ " + key + " : " + integer + " ]");
}
/*
* [ 丁 : 20 ]
* [ 甲 : 30 ]
* [ 乙 : 40 ]
* [ 丙 : 20 ]
*/

增强 for 循环遍历
HashMap<String, Integer> map = new HashMap<>();
map.put("甲", 30);
map.put("乙", 40);
map.put("丙", 20);
map.put("丁", 20);
Set<String> keySet = map.keySet();
for (String key : keySet) {
Integer integer = map.get(key);
System.out.println("[ " + key + " : " + integer + " ]");
}
/*
* [ 丁 : 20 ]
* [ 甲 : 30 ]
* [ 乙 : 40 ]
* [ 丙 : 20 ]
*/

通过获取键值对对象的 set 集合来遍历
HashMap<String, Integer> map = new HashMap<>();
map.put("甲", 30);
map.put("乙", 40);
map.put("丙", 20);
map.put("丁", 20);
// Entry 是 Map 中的内部接口,需要用 Map 来调用 Entry 所以是 Map. 系统自动生成时省略
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
// 获取迭代器
Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
while (iterator.hasNext()) {
// 获取 Entry 对象
Entry<String, Integer> entry = iterator.next();
// 获取 key
String key = entry.getKey();
// 获取 value
Integer value = entry.getValue();
System.out.println("[ " + key + " : " + value + " ]");// 或者 System.out.println(entry);
}

/*
* [ 丁 : 20 ]
* [ 甲 : 30 ]
* [ 乙 : 40 ]
* [ 丙 : 20 ]
*/

内部接口如:
interface InterA{
// InterB 是 InterA 的内部接口
interface InterB{
public abstract void fun();
}
}
// 创建一个类,实现 InterB 接口
//
class InterBImpl implements InterA.InterB{
@Override
public void fun() {

}
}

HashMap<String, Integer> map = new HashMap<>();
map.put("甲", 30);
map.put("乙", 20);
map.put("丙", 20);
map.put("丁", 20);
for (Entry<String, Integer> entry : map.entrySet()) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println("[ " + key + " : " + value + " ]");
}
/*
* [ 丁 : 20 ]
* [ 甲 : 30 ]
* [ 乙 : 40 ]
* [ 丙 : 20 ]
*/

键盘输入字符串 统计字符串中每个字符出现的次数
System.out.println("请输入字符串");
Scanner scanner = new Scanner(System.in);
String string = scanner.nextLine();
// 转字符数组,为了取出每一个字符
char[] charArray = string.toCharArray();
// 创建
10461
map
HashMap<Character, Integer> map = new HashMap<>();
// 遍历
for (int i = 0; i < charArray.length; i++) {
// 将每一个字符存入 map 中
// 判断要存的字符是否存在于 map 中
char key = charArray[i];
Integer value = map.get(key);
if (value == null) {
// key 不存在 map 中
map.put(key, 1);
} else {
// key 存在于 map 中
// 利用 key 把对应值取出来 + 1
Integer v = map.put(charArray[i], 1);
// 重新存回去,覆盖原先 value 的部分
map.put(key, v + 1);
}
}
System.out.println(map);
scanner.close();
// 请输入字符串
// asddwqdsadqwdsdgvfgdhjsfgjdfggdsgf
// {a=2, q=2, s=5, d=9, v=1, f=4, w=2, g=6, h=1, j=2}

LindedHashMap

LinkedHashMap
特点:有序(怎么存储,怎么打印)

LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("鹏", 18);
map.put("忠", 22);
map.put("水", 20);
map.put("茜", 28);
System.out.println(map);            // {鹏=18, 忠=22, 水=20, 茜=28}

// 创建一个 treemap key 保存学生, value 保存户籍
// 按年龄排序
TreeMap<Student, String> map = new TreeMap<>();
map.put(new Student("鹏", 21), "安徽");
map.put(new Student("北", 22), "河南");
map.put(new Student("轩", 23), "江苏");
map.put(new Student("水", 18), "浙江");
for (Entry<Student, String> entry : map.entrySet()) {
Student key = entry.getKey();
String value = entry.getValue();
System.out.println("[ " + key + " 来自 : " + value + " ]");
}
/*
* [ [ 姓名 : 水 , 年龄 : 18 ] 来自 : 浙江 ]
* [ [ 姓名 : 鹏 , 年龄 : 21 ] 来自 : 安徽 ]
* [ [ 姓名 : 北 , 年龄 : 22 ] 来自 : 河南 ]
* [ [ 姓名 : 轩 , 年龄 : 23 ] 来自 : 江苏 ]
*/

// Collection 类中的方法(静态方法)
ArrayList<Integer> list  = new ArrayList<>();
list.add(12);// 自动装箱
list.add(10);
list.add(84);
list.add(20);
list.add(24);
list.add(36);
list.add(42);
list.add(57);
System.out.println(list);           // [12, 10, 84, 20, 24, 36, 42, 57]

// 随机交换集合中值得位置(洗牌)
Collections.shuffle(list);
System.out.println(list);           // [12, 42, 24, 84, 20, 10, 36, 57]

// 排序
Collections.sort(list);
System.out.println(list);           // [10, 12, 20, 24, 36, 42, 57, 84]

// 二分查找
int index = Collections.binarySearch(list, 36);
System.out.println(index);          // 4

// 反转集合
Collections.reverse(list);
System.out.println(list);           // [84, 57, 42, 36, 24, 20, 12, 10]

ArrayList<Student> list = new ArrayList<>();
list.add(new Student("北", 22));
list.add(new Student("鹏", 21));
list.add(new Student("轩", 23));
// 排序(对象排序时,需要实现 Comparable 接口,编写排序规则)
Collections.sort(list);
System.out.println(list);           // [[ 姓名 : 鹏 , 年龄 : 21 ], [ 姓名 : 北 , 年龄 : 22 ], [ 姓名 : 轩 , 年龄 : 23 ]]

/*
* 使用 ArrayList 模拟三人斗地主
* 1.洗牌
* 2.发牌
* 3.看牌
* 分析:
* 1.先创建一副牌(使用 ArrayList)
* 2.洗牌(suffle)
* 3.发牌分三人(三个 list)和底牌部分(list)
* 4.看牌(打印 list)
*
*/
public class Demo {
public static void main(String[] args) {
ArrayList<String> poker = new ArrayList<>();
// 拼接字符串
String[] AllColors = {"黑桃","红桃","梅花","方片"};
String[] AllNum = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
for (String colors : AllColors) {
for (String num : AllNum) {
// 拼接字符串
String pokerStr = colors + num;
// 把牌装进集合中
poker.add(pokerStr);
}
}
// 添加大小王
poker.add("小王");
poker.add("大王");
// 洗牌
Collections.shuffle(poker);
// 创建4个装牌的集合
// 0  3  6  9
ArrayList<String> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
ArrayList<String> list3 = new ArrayList<>();
ArrayList<String> list4 = new ArrayList<>();
// 遍历牌的集合
for (int i = 0; i < poker.size(); i++) {
// 把每一张牌取出来
String pokers = poker.get(i);
// 按发牌顺序添加不同集合中
if (i > 50) {
// 51 52 53
list4.add(pokers);
} else if (i % 3 == 0) {
// 给第一个人发牌
list1.add(pokers);
} else if (i % 3 == 1) {
// 给第二个人发牌
list2.add(pokers);
}else{
// 给第三个人发牌
list3.add(pokers);
}
}
System.out.println("鹏的手牌:");
System.out.println(list1);
System.out.println("水的手牌:");
System.out.println(list2);
System.out.println("孟的手牌:");
System.out.println(list3);
System.out.println("底牌:");
System.out.println(list4);
}
}
/*
* 鹏的手牌:
* [方片9, 黑桃Q, 梅花9, 方片3, 黑桃J, 黑桃9, 方片4, 红桃A, 黑桃A, 梅花7, 方片K, 方片10, 梅花8, 黑桃6, 黑桃3, 黑桃7, 黑桃5]
* 水的手牌:
* [红桃J, 方片7, 梅花10, 方片2, 红桃10, 梅花A, 大王, 梅花2, 方片Q, 红桃8, 红桃9, 红桃5, 黑桃4, 方片8, 梅花6, 方片A, 红桃3]
* 孟的手牌:
* [梅花J, 红桃7, 小王, 黑桃K, 红桃K, 梅花5, 黑桃10, 红桃4, 梅花K, 红桃2, 方片J, 梅花4, 红桃6, 红桃Q, 梅花Q, 方片5, 方片6]
* 底牌:
* [黑桃8, 梅花3, 黑桃2]
*/

/*
* 使用 map 模拟三人斗地主
* 1.洗牌
* 2.发牌
* 3.看牌
*/
public class Demo {
public static void main(String[] args) {
// 创建 map 集合
HashMap<Integer, String> poker = new HashMap<>();
// 创建一个集合,保存索引
ArrayList<Integer> list = new ArrayList<>();
// 创建牌的索引
int index = 1;
// 拼接字符串
String[] AllColors = {"黑桃","红桃","梅花","方片"};
String[] AllNum = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
for (String  num: AllNum) {
for (String colors : AllColors) {
// 拼接字符串
String string = colors + num;
// 把牌装进集合中
poker.put(index, string);
// 把索引装进 list 中(为洗牌准备)
list.add(index);
// 让索引自增
index++;
}
}
// map 中添加大小王,list 中添加 index,index 自增
poker.put(index, "小王");
list.add(index++);
poker.put(index, "大王");
list.add(index);
// 洗牌(随机排序索引)
Collections.shuffle(list);
// 发牌(将索引发出去)
// 创建4个 TreeSet 保存索引
TreeSet<Integer> set1 = new TreeSet<>();
TreeSet<Integer> set2 = new TreeSet<>();
TreeSet<Integer> set3 = new TreeSet<>();
TreeSet<Integer> set4 = new TreeSet<>();
// 发牌(发索引)
for (int i = 0; i < list.size(); i++) {
// 取出每个索引
Integer integer = list.get(i);
// 按顺序发牌
if (i > 50) {
set4.add(integer);
} else if (i % 3 == 0) {
// 给第一个人发牌
set1.add(integer);
} else if (i % 3 == 1) {
// 给第二个人发牌
set2.add(integer);
}else{
// 给第三个人发牌
set3.add(integer);
}
}
// 看牌(去 map 中使用索引把对应的牌取出来打印)
lookPokers(poker, set1, "鹏");
lookPokers(poker, set2, "水");
lookPokers(poker, set3, "龙");
lookPokers(poker, set4, "底牌");
}
// 看牌的方法
public static void lookPokers(HashMap<Integer, String> map, TreeSet<Integer> set, String name) {
if (!name.equals("底牌")) {
System.out.println(name + "的手牌:");
} else {
System.out.println("底牌:");
}
// 遍历索引的 set, 取出每一个索引,再去 map 中找到对应的牌
for (Integer key : set) {
// 取出的牌
String string = map.get(key);
System.out.print(string + " ");
}
System.out.println();
}
}
/*
* 鹏的手牌:
* 梅花3 黑桃4 方片4 梅花5 方片5 方片6 红桃7 梅花7 黑桃10 梅花10 红桃J 方片Q 梅花K 方片K 红桃2 方片2 小王
* 水的手牌:
* 方片3 红桃4 梅花4 黑桃5 黑桃6 梅花6 黑桃7 红桃8 梅花8 方片9 红桃10 梅花J 方片J 红桃Q 黑桃K 黑桃A 红桃A
* 龙的手牌:
* 红桃3 红桃5 红桃6 方片8 黑桃9 红桃9 梅花9 方片10 黑桃J 黑桃Q 梅花Q 红桃K 梅花A 方片A 黑桃2 梅花2 大王
* 底牌:
* 黑桃3 方片7 黑桃8
*/

Map 的嵌套

/*
* Java学科
* java 1班  -- 保存是学生 和 户籍
* java 2班  -- 保存是学生 和 户籍
*
* Java学科 是一个map
* 保存了两个键值对 ----  1班 和 2班
*
* 1班 也是一个 map
* 保存 ----  学生 户籍
*/
public class Demo {
public static void main(String[] args) {
HashMap<Student, String> class1 = new HashMap<>();// 1班
HashMap<Student, String> class2 = new HashMap<>();// 2班
HashMap<HashMap<Student, String>, String> subject = new HashMap<>();// 学科
class1.put(new Student("鹏", 21), "安徽");
class1.put(new Student("北", 22), "河南");
class1.put(new Student("剑", 20), "江苏");
class2.put(new Student("轩", 23), "江苏");
class2.put(new Student("水", 19), "浙江");
class2.put(new Student("孟", 18), "浙江");
subject.put(class1, "Java1班");
subject.put(class2, "Java2班");
// 遍历学科,找到班
for (HashMap<Student, String> classes : subject.keySet()) {
// 先获取学科的 value
String subjectValue = subject.get(classes);
System.out.println(subjectValue + ":");
// 遍历班,打印学生和对应户籍
for (Student student : classes.keySet()) {
// 打印班对应的 value(学生的户籍)
String classesValue = classes.get(student);
System.out.println(student + " 户籍 : " + classesValue);
}
System.out.println();
}
}
}
/*
* Java1班:
* [ 姓名 : 北 , 年龄 : 22 ] 户籍 : 河南
* [ 姓名 : 鹏 , 年龄 : 21 ] 户籍 : 安徽
* [ 姓名 : 剑 , 年龄 : 20 ] 户籍 : 江苏
*
* Java2班:
* [ 姓名 : 水 , 年龄 : 19 ] 户籍 : 浙江
* [ 姓名 : 轩 , 年龄 : 23 ] 户籍 : 江苏
* [ 姓名 : 孟 , 年龄 : 18 ] 户籍 : 浙江
*/