Map集合（json字符串转map集合）

1概述

Map集合概述

Map是一个接口，只要是实现了该接口的类都是双列集合

Key：键 Value：值

双列集合每次存储元素都需要存储两个元素，一个元素称为键，一个元素称为值，简称为键值对

特点：键必须唯一，值可以重复。键值对关系又称为映射关系

2 Map常用子类

Map接口常用实现类

HashMap

LinkedHashMap

Hashtable(过时)

3 Map接口中的常用方法

V put(K key, V value)

存储键值对

如果键存在，则使用新值替换旧值，返回旧值。

如果键不存在，则直接存储，返回null

V get(Object key)

根据键获得对应的值,如果键不存在，则返回null

V remove(Object key)

根据键删除键值对

返回键对应的值

int size();

获得键值对的对数

void clear()

清空集合

boolean containsKey(Object key)

判断集合中是否包含指定的键，如果包含返回true，否则false

boolean isEmpty()

判断集合是否为空，为空返回true，否则false

示例

import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args){
// 创建集合对象
// 键 值
Map<String,String> map = new HashMap<>();
// 存储键值对
String name = map.put("name","TiMi");
System.out.println(name); // null
name = map.put("name","Jerry");
System.out.println(name); // jack
map.put("gender","男");
map.put("age","23");
System.out.println(map);
// 根据键获得对应的值
name = map.get("name");
System.out.println(name);
// 根据键删除键值对
System.out.println(map.remove("name"));
System.out.println(map);
// 获得键值对对数
System.out.println(map.size());
// 判断是否包含name键
System.out.println(map.containsKey("gender"));
// 清空集合
map.clear();
System.out.println(map);
// 判断集合是否为空
System.out.println(map.isEmpty());
}
}

4 Map集合遍历键找值方式

/**

Map集合遍历不能直接使用增强for或迭代器遍历。

Map集合的遍历方式1：通过键找值的方式

调用Map集合的keySet方法获得键集合

使用增强for或迭代器遍历键集合

调用Map集合的get方法根据键获得对应的值

Map集合与遍历相关的方法

Set<K> keySet() 获得键的集合

*/

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class MapDemo01 {
public static void main(String[] args){
// 创建Map集合对象
HashMap<Integer,String> map = new HashMap<>();
// 存储键值对
map.put(1,"张三");
map.put(2,"李四");
map.put(3,"王五");
map.put(4,"老六");
// 获得键集合
Set<Integer> keySet = map.keySet();
// 使用增强for遍历键集合
for(Integer key:keySet){
// 根据键获得值
String value = map.get(key);
System.out.println(key+"="+value);
}
System.out.println("-------------");
// 使用迭代器遍历键集合
Iterator<Integer> it = keySet.iterator();
while (it.hasNext()){
// 获得键
Integer key = it.next();
// 根据键获得值
String value = map.get(key);
System.out.println(key+"="+value);
}
}
}

5 Entry键值对对象

Entry对象的概述

每一个键值对都封装成一个Entry对象

Entry对象又称为键值对对象

Entry对象常用方法

K getKey() 获得键

V getValue() 获得值

Map集合与遍历相关的方法

Set<Map.Entry<K,V>> entrySet() 获得Entry对象的集合

6 Map集合遍历键值对方式

/**

Map集合的遍历方式2：通过键值对对象遍历

调用Map集合的entrySet方法获得Entry对象集合

使用增强for或迭代器遍历Entry对象集合

调用Entry对象的getKey和getValue方法获得键和值。

Map集合与遍历相关的方法

Set<Map.Entry<K,V>> entrySet() 获得Entry对象的集合

*/

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo02 {
public static void main(String[] args){
// 创建Map集合对象
HashMap<Integer,String> map = new HashMap<>();
// 存储键值对
map.put(1,"张三");
map.put(2,"李四");
map.put(3,"王五");
map.put(4,"老六");
// 获得Entry对象的集合
Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
// 使用增强for遍历集合
for(Map.Entry<Integer,String> entry:entrySet ){
// 调用方法获得键和值
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"="+value);
}
System.out.println("----------------");
// 使用迭代器遍历
Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();
while (it.hasNext()){
// 获得Entry对象
Map.Entry<Integer, String> entry = it.next();
System.out.println(entry.getKey()+"="+ entry.getValue());
}
}
}

7 HashMap存储自定义类型键值

示例

import java.util.Objects;
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
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 String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}

测试类：

/*

使用HashMap存储自定义对象

每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系

则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值

注意，学生姓名相同并且年龄相同视为同一名学生

注意事项

使用双列集合存储自定义对象，如果自定义对象作为键，需要实现去重效果

自定义类需要重写hashCode和equals方法

*/

import java.util.HashMap;
import java.util.Set;
public class MapDemo03 {
public static void main(String[] args){
// 创建Map集合对象
HashMap<Student,String> map = new HashMap<>();
map.put(new Student("张三",20),"湘江"); // 2134253 % 16 = 2
map.put(new Student("李四",18),"四川"); // 4567866 % 16 = 3
map.put(new Student("王五",25),"海南"); // 67898765 % 16 = 4
map.put(new Student("老六",20),"湖南"); // 8987653 % 16 = 2
// 遍历输出
Set<Student> keySet = map.keySet();
for (Student stu: keySet) {
System.out.println(stu+"="+map.get(stu));
}
}
}

当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)

如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放

8 LinkedHashMap

/**

LinkedHashMap概述

继承HashMap，能够保证存取有顺序。

底层是哈希表+链表

*/

import java.util.LinkedHashMap;
public class MapDemo04 {
public static void main(String[] args){
// 创建集合对象
LinkedHashMap<String,String> map = new LinkedHashMap<>();
map.put("aaa","bbb");
map.put("ccc","ddd");
map.put("ABC","afdsg");
map.put("1234","lll");
map.put("sfdg6515","aaa");
System.out.println(map);
}
}