Map接口：
Map接口与Collection接口无继承关系。
区别：Collection中的元素是孤立的，一个一个存进去的。
Map作为一个映射集合，每一个元素包含Key-value对（键-值对）。即，Map元素总是成对出现的。
Map中的value对象可以重复，但Key不能重复。
Map接口的常用集合：
1.HashMap集合，HashMap类与HashSet类基本相同，都是无序的，
2.LinkedHashMap集合，存储数据是有序的。
Map接口的常用方法：
package Demo2; import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set; public class Demo1 {
public static void main(String[] args) {
function();
function1();
function2();
} private static void function2() {
//处理映射中的键/值对组的视图操作
HashMap<Integer,String> h=new HashMap<>();
h.put(10,"aaa");
h.put(20,"bbb");
h.put(30,"ccc");
h.put(40,"ddd");
System.out.println(h);//{20=bbb, 40=ddd, 10=aaa, 30=ccc}
Set<Integer> set = h.keySet();//keySet()方法 返回此映射中包含的键的Set视图（即：将该映射中的键都放入 一个Set集合）
System.out.println(set);//[20, 40, 10, 30]
//values()方法，返回此映射中包含的值的Collection视图。（将该映射中的值都放入一个Collection集合）
Collection<String> val = h.values();
System.out.println(val);//[bbb, ddd, aaa, ccc]
} private static void function1() {
//查询操作
HashMap<String,Integer> h=new HashMap<>();
h.put("张三",18);//put(key,value)方法，将指定的value值与此映射中的指定键key关联
h.put("李四",20);
h.put("小明",22);
h.put("小红",26);
System.out.println(h);//{李四=20, 张三=18, 小明=22, 小红=26}
Integer s = h.get("张三");//get(key)返回指定键key的值，如果此映射不包含该键的映射关系，则返回null。
System.out.println(s);//
int size = h.size();//size()返回映射中的键-值关键字（即集合中的元素个数，每一个 键-值 为一个元素）
System.out.println(size);//
boolean b = h.containsKey("张三");//containsKey(key)判断映射中是否存在关键字key
System.out.println(b);//true containsValue(value) 判断映射中是否存在值value
h.clear();
boolean b1 = h.isEmpty();// 如果此映射不包含键-值映射关系，则返回 true。
System.out.println(b1);//true
} private static void function() {
//添加删除操作
Map<String,Integer> m=new HashMap<>();
m.put("张三",18);//put(key,value)方法，将指定的value值与此映射中的指定键key关联
m.put("李四",20);
m.put("小明",22);
m.put("小红",24);
System.out.println(m);//{李四=20, 张三=18, 小明=22, 小红=24}//输出是无序的
m.remove("小明");//remove(key) :如果存在一个映射关系，则将其从此映射中 移除。
System.out.println(m);//{李四=20, 张三=18, 小红=24}
m.clear();//从此映射中移除所有的映射关系
System.out.println(m);//{}
}
}
Map接口的遍历：
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set; public class Demo2 {
public static void main(String[] args) {
function();
function2();
} private static void function2() {
//增强性for循环
Map<Integer,String> h=new HashMap<>();
h.put(11,"aa");
h.put(22,"bb");
h.put(33,"cc");
h.put(44,"dd");
for (Integer key : h.keySet()) {
System.out.println(key+":"+h.get(key));
/* 33:cc
22:bb
11:aa
44:dd*/
}
} private static void function() {
//迭代器遍历
Map<Integer,String> m=new HashMap<>();
m.put(10,"aaa");
m.put(20,"bbb");
m.put(30,"ccc");
m.put(40,"ddd");
Set<Integer> set = m.keySet();
Iterator<Integer> it = set.iterator();
while (it.hasNext()) {
Integer key = it.next();
String val = m.get(key);
System.out.println(key+":" +val);/*20:bbb
40:ddd
10:aaa
30:ccc*/ }
}
}
Map第二种遍历方式：Map.Entry接口遍历
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*主要用到Entry接口中的entrySet方法来获得映射的Set视图，然后用getKey，getValue方法来获得键和值*/
public class Demo3 {
public static void main(String[] args) {
function();
} private static void function() {
//迭代器循环
Map<Integer,String> m=new HashMap<>();
m.put(10,"aa");
m.put(20,"bb");
m.put(30,"cc");
m.put(40,"dd");
Set<Map.Entry<Integer, String>> set = m.entrySet();
Iterator<Map.Entry<Integer, String>> it = set.iterator();
while (it.hasNext()) {
Map.Entry<Integer, String> next = it.next();
Integer key = next.getKey();//getKey返回与此项对应的键
String value = next.getValue();//getValue 返回与此项对应的值
System.out.println(key+":"+value);
}
/* 20:bb
40:dd
10:aa
30:cc*/
}
}
LinkedHashMap类：
import java.util.LinkedHashMap;
public class Demo4 {
public static void main(String[] args) {
function();
}
private static void function() {
LinkedHashMap<Integer,String> link=new LinkedHashMap<>();
link.put(10,"aaa");
link.put(20,"bb");
link.put(30,"cc");
link.put(40,"dd");
System.out.println(link);
for (Integer key : link.keySet()) {
System.out.println(key+":" +link.get(key));
}
/* {10=aaa, 20=bb, 30=cc, 40=dd}
10:aaa
20:bb 结果可以看出是有序的
30:cc
40:dd*/
}
}
综合练习：
Map嵌套Map：
package Zuoye; import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set; public class Demo {
public static void main(String[] args) {
function1();
function2();
function3();//增强型for循环遍历嵌套Map
} private static void function3() {
Map<String, Map<Integer, String>> aaa = function();
//创建aaa映射的Set视图
Set<Map.Entry<String, Map<Integer, String>>> aSet = aaa.entrySet();
for (Map.Entry<String, Map<Integer, String>> amap : aSet) {
//获得下一个aaa映射对象的键
String className = amap.getKey();
System.out.println(className);
//获得值
Map<Integer, String> classInfo = amap.getValue();
Set<Map.Entry<Integer, String>> student = classInfo.entrySet();
for (Map.Entry<Integer, String> stu : student) {
Integer stuNum = stu.getKey();
String stuName = stu.getValue();
System.out.println(stuNum+":"+stuName);
}
}
} private static void function2() {
//调用Map嵌套对象
Map<String, Map<Integer, String>> aaa = function();
//创建aaa的Set视图对向eMap，通过Entry接口
Set<Map.Entry<String, Map<Integer, String>>> eMap = aaa.entrySet();
//创建eMop的迭代器对象it
Iterator<Map.Entry<String, Map<Integer, String>>> it = eMap.iterator();
while (it.hasNext()) {
//获得下一个元素(Map(Map))对象赋值给classMap
Map.Entry<String, Map<Integer, String>> classMap = it.next();
//获得Map(Map)的键，即班级名 ，通过getKey方法
String className = classMap.getKey();
//获得Map(Map)的值，即(Map)对象赋值给classInfo
Map<Integer, String> classInfo = classMap.getValue();
//给(map)映射对象创建Set视图，存储学生信息
Set<Map.Entry<Integer, String>> stu = classInfo.entrySet();
//创建迭代器
Iterator<Map.Entry<Integer, String>> itstu = stu.iterator();
while (itstu.hasNext()) {
//获取下一个学生元素
Map.Entry<Integer, String> Student = itstu.next();
//获得学生对象的键
Integer key = Student.getKey();
//获得学生的值
String value = Student.getValue();
System.out.println(className+":"+key+":"+value);
}
}
} private static void function1() {
//迭代器第一种map循环
Map aaa = function();
Set set = aaa.keySet();
Iterator it = set.iterator();
while (it.hasNext()) {
Object className = it.next();
System.out.println(className);
Map ClassInfo = (Map) aaa.get(className);
Set Student = ClassInfo.keySet();
Iterator its = Student.iterator();
while (its.hasNext()) {
Integer StudentNum = (Integer) its.next();
String studentName = (String) ClassInfo.get(StudentNum);
System.out.println(StudentNum+":"+studentName);
/*hoodp班
1:许锦迪
2:王家宝
java班
1:朱东阳
2:常军凯*/
}
}
} private static Map<String, Map<Integer, String>> function() {
//创建Map嵌套Map的对象
//创建java班Map集合
Map<Integer,String> java=new HashMap<Integer,String>();
java.put(001,"朱东阳");
java.put(002,"常军凯");
//创建hoodp班Map集合
Map<Integer,String> hoodp=new HashMap<Integer,String>();
hoodp.put(001,"许锦迪");
hoodp.put(002,"王家宝");
//创建aaaMap集合
Map<String,Map<Integer,String>> aaa=new HashMap<String,Map<Integer,String>>();
aaa.put("java班",java);
aaa.put("hoodp班",hoodp); return aaa;
}
}