A: 需求: 根据学号获取学生姓名 B:Map接口概述 查看API可以知道： 将键映射到值的对象 一个映射不能包含重复的键 每个键最多只能映射到一个值 C:Map接口和Collection接口的不同 Map是双列的,Collection是单列的 Map的键唯一,Collection的子体系Set是唯一的 Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效
案例:
import java.util.ArrayList; import java.util.HashMap; import java.util.TreeMap; public class MyTest { public static void main(String[] args) { //我们有学生 有可能会有重名学生 // key value 像这种键值映射关系的数据，在生活中经常键 // s001--------张三 // s002---------李四 // s003---------王五 ArrayList<String> list = new ArrayList<>(); list.add("s001--------张三"); list.add("s002---------李四"); list.add("s003---------王五"); //取出 s003 王五 String s = list.get(2); String[] split = s.split("\\-+"); System.out.println(split[0]); System.out.println(split[1]); //Java 为了我们更加方便的去操作，这种键值映射关系的数据，给我们提供了另外一种集合叫做Map集合 //Map<K,V>将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 // HashMap, Hashtable, LinkedHashMap TreeMap Properties, } }A:Map集合的功能概述 a:添加功能 V put(K key,V value):添加元素。这个其实还有另一个功能?替换 如果键是第一次存储，就直接存储元素，返回null 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值 b:删除功能 void clear():移除所有的键值对元素 V remove(Object key)：根据键删除键值对元素，并把值返回 c:判断功能 boolean containsKey(Object key)：判断集合是否包含指定的键 boolean containsValue(Object value):判断集合是否包含指定的值 boolean isEmpty()：判断集合是否为空 d:获取功能 Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合 V get(Object key):根据键获取值 Set keySet():获取集合中所有键的集合 Collection values():获取集合中所有值的集合 e:长度功能 int size()：返回集合中的键值对的对数
案例一：
import java.util.Collection; import java.util.HashMap; import java.util.HashSet; public class MyTest2 { public static void main(String[] args) { //Collection 单列 //Map 双列集合 //HashSet 用的是HashMap来存的 //基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（ //双列集合，所有的数据结构,只跟键有关，跟值没关系 HashMap<String, String> map = new HashMap<>(); String v = map.put("文章", "马伊琍"); System.out.println(v); //当发生键相同的时候，值就会覆盖，返回的是旧值 v = map.put("文章", "姚笛"); System.out.println(v); map.put("贾乃亮", "李小璐"); map.put("王宝强", "蓉儿"); map.put("陈羽凡", "白百合"); map.put("武大", "潘金莲"); System.out.println(map); } }结果： null 马伊琍 {贾乃亮=李小璐, 文章=姚笛, 王宝强=蓉儿, 武大=潘金莲, 陈羽凡=白百合}
案例一：
import java.util.HashMap; public class MyTest3 { public static void main(String[] args) { //先存 键是 String 类型 值是Student类型的 HashMap<String, Student> hashMap = new HashMap<>(); hashMap.put("s001",new Student("张三0",23)); hashMap.put("s001", new Student("张三0", 23)); hashMap.put("s001", new Student("张三0", 23333)); hashMap.put("s002", new Student("张三1", 23)); hashMap.put("s003", new Student("张三2", 23)); hashMap.put("s004", new Student("张三3", 23)); hashMap.put("s005", new Student("张三4", 23)); System.out.println(hashMap); } }结果： {s004=Student{name=‘张三3’, age=23}, s003=Student{name=‘张三2’, age=23}, s005=Student{name=‘张三4’, age=23}, s002=Student{name=‘张三1’, age=23}, s001=Student{name=‘张三0’, age=23333}}
案例二：
import java.util.Objects; public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { 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 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); } } import java.util.HashMap; public class MyTest4 { public static void main(String[] args) { // //双列集合，所有的数据结构,只跟键有关，跟值没关系 //存 键是 Student 值是String HashMap<Student, String> hashMap = new HashMap<>(); hashMap.put(new Student("张三0", 23), "s001"); hashMap.put(new Student("张三0", 23), "s001"); hashMap.put(new Student("张三1", 23), "s002"); hashMap.put(new Student("张三2", 23), "s003"); hashMap.put(new Student("张三3", 23), "s004"); hashMap.put(new Student("张三4", 23), "s005"); System.out.println(hashMap); } }结果： {Student{name=‘张三0’, age=23}=s001, Student{name=‘张三3’, age=23}=s004, Student{name=‘张三2’, age=23}=s003, Student{name=‘张三4’, age=23}=s005, Student{name=‘张三0’, age=23}=s001, Student{name=‘张三1’, age=23}=s002}
案例三：
import java.util.HashMap; public class MyTest2 { public static void main(String[] args) { HashMap<Integer, String> hashMap = new HashMap<>(); hashMap.put(1,"aaa"); hashMap.put(1, "bbb"); hashMap.put(2, "ccc"); hashMap.put(3, "ddd"); hashMap.put(4, "eee"); hashMap.put(5, "fff"); // hashMap.clear(); //清空集合中所有的元素 hashMap.remove(4);//根据键移除这个键值对 boolean empty = hashMap.isEmpty(); System.out.println(empty); System.out.println(hashMap); } }结果： false {1=bbb, 2=ccc, 3=ddd, 5=fff}
案例四：
import java.util.HashMap; import java.util.Set; public class MyTest3 { public static void main(String[] args) { HashMap<Integer, String> hashMap = new HashMap<>(); hashMap.put(1, "bbb"); hashMap.put(2, "ccc"); hashMap.put(3, "ddd"); hashMap.put(4, "eee"); hashMap.put(5, "fff"); //遍历map集合的方式1 键找值 Set<Integer> integers = hashMap.keySet(); // String s = hashMap.get(1); //键找值 for (Integer key : integers) { System.out.println(key + "===" + hashMap.get(key)); } } }结果：
2===ccc 3===ddd 4===eee 5===fff案例五：
import java.util.HashMap; import java.util.Map; import java.util.Set; public class MyTest4 { public static void main(String[] args) { HashMap<Integer, String> hashMap = new HashMap<>(); hashMap.put(1, "bbb"); hashMap.put(2, "ccc"); hashMap.put(3, "ddd"); hashMap.put(4, "eee"); hashMap.put(5, "fff"); //entrySet() 获取键值对 对象 放到Set集合里面去 Set<Map.Entry<Integer, String>> entries = hashMap.entrySet(); //K getKey () //返回与此项对应的键。 //V getValue () //返回与此项对应的值。 for (Map.Entry<Integer, String> entry : entries) { //System.out.println(entry); Integer key = entry.getKey(); String value = entry.getValue(); System.out.println(key+"==="+value); } } }结果： 1=bbb 2=ccc 3=ddd 4=eee 5===fff
案例五：
import java.util.Collection; import java.util.HashMap; import java.util.Set; public class MyTest { public static void main(String[] args) { HashMap<Integer, String> hashMap = new HashMap<>(); hashMap.put(1, "aaa"); hashMap.put(1, "bbb"); hashMap.put(2, "ccc"); hashMap.put(3, "ddd"); hashMap.put(4, "eee"); hashMap.put(5, "fff"); // HashMap允许使用 null 值和 null 键。（ hashMap.put(null,null); System.out.println(hashMap.get(null)); //获取所有键的集合 Set<Integer> integers = hashMap.keySet(); System.out.println(integers); //获取所有值的集合 Collection<String> values = hashMap.values(); System.out.println(values); //判断集合有没有1这个键 boolean b = hashMap.containsKey(1); //判断集合中有么有bbb这个值 boolean flag = hashMap.containsValue("bbb"); //获取集合的长度 System.out.println(hashMap.size()); } }结果： null [null, 1, 2, 3, 4, 5] [null, bbb, ccc, ddd, eee, fff] 6
A:LinkedHashMap的概述: Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序 B:LinkedHashMap的特点： 底层的数据结构是链表和哈希表 元素有序 并且唯一 元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证 Map集合的数据结构只和键有关
C:案例演示: LinkedHashMap的特点
案例一：
结果：
aaa===AAA2 ccc===CCC ddd===DDD eee===EEE ------------------- aaa===AAA2 ccc===CCC ddd===DDD eee===EEETreeMap 键不允许插入null
A: TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性 排序分为自然排序和比较器排序 线程是不安全的效率比较高
案例：
import java.util.Set; import java.util.TreeMap; public class TreeMapDemo { public static void main(String[] args) { TreeMap<Integer, String> treeMap = new TreeMap<>(); treeMap.put(10,"aaaa"); treeMap.put(100, "aaaa"); treeMap.put(1, "aaaa"); treeMap.put(0, "aaaa"); treeMap.put(1044, "aaaa"); treeMap.put(1088, "aaaa"); Set<Integer> integers = treeMap.keySet(); for (Integer integer : integers) { System.out.println(integer+"=="+treeMap.get(integer)); } } }案例一：
import java.util.Map; import java.util.Set; import java.util.TreeMap; public class TreeMapDemo2 { public static void main(String[] args) { TreeMap<String, Integer> treeMap = new TreeMap<>(); treeMap.put("aaa", 111); treeMap.put("ccc", 1110); treeMap.put("d", 1119); treeMap.put("fff", 1114); treeMap.put("ggg", 1141); treeMap.put("sss", 1161); Set<Map.Entry<String, Integer>> entries = treeMap.entrySet(); for (Map.Entry<String, Integer> entry : entries) { String key = entry.getKey(); Integer value = entry.getValue(); System.out.println(key+"==="+value); } } }案例二：
import java.util.Map; import java.util.Set; import java.util.TreeMap; public class TreeMapDemo2 { public static void main(String[] args) { TreeMap<String, Integer> treeMap = new TreeMap<>(); treeMap.put("aaa", 111); treeMap.put("ccc", 1110); treeMap.put("d", 1119); treeMap.put("fff", 1114); treeMap.put("ggg", 1141); treeMap.put("sss", 1161); Set<Map.Entry<String, Integer>> entries = treeMap.entrySet(); for (Map.Entry<String, Integer> entry : entries) { String key = entry.getKey(); Integer value = entry.getValue(); System.out.println(key+"==="+value); } } }案例一：
import java.util.Objects; public class Student implements Comparable<Student>{ private String name; private int age; public Student() { } public Student(String name, int age) { 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 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); } @Override public int compareTo(Student o) { int num=this.age-o.age; int num2=num==0?this.name.compareTo(o.name):num; return num2; } } import java.util.Map; import java.util.Set; import java.util.TreeMap; public class MyTest { public static void main(String[] args) { TreeMap<Student, String> treeMap = new TreeMap<>(); treeMap.put(new Student("张三0", 23), "111"); treeMap.put(new Student("张三0", 23), "222"); treeMap.put(new Student("张三0", 23333), "222"); treeMap.put(new Student("张三1", 24), "444"); treeMap.put(new Student("张三2", 26), "555"); treeMap.put(new Student("张三3", 25), "666"); treeMap.put(new Student("张三4", 28), "777"); Set<Map.Entry<Student, String>> entries = treeMap.entrySet(); for (Map.Entry<Student, String> entry : entries) { Student key = entry.getKey(); String value = entry.getValue(); System.out.println(key+"==="+value); } } }案例二：
import java.util.Objects; public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { 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 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); } } import java.util.Comparator; import java.util.TreeMap; public class MyTest2 { public static void main(String[] args) { TreeMap<Student, String> treeMap = new TreeMap<>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { int num = s1.getAge()-s2.getAge(); int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; return -num2; } }); treeMap.put(new Student("张三0", 23), "111"); treeMap.put(new Student("张三0", 23), "222"); treeMap.put(new Student("张三0", 23333), "222"); treeMap.put(new Student("张三1", 24), "444"); treeMap.put(new Student("张三2", 26), "555"); treeMap.put(new Student("张三3", 25), "666"); treeMap.put(new Student("张三4", 28), "777"); } }A:案例演示: 需求：统计字符串中每个字符出现的次数 “aababcabcdabcde”,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
案例： //A: //案例演示: //需求：统计字符串中每个字符出现的次数 //“aababcabcdabcde”, 获取字符串中每一个字母出现的次数要求结果:a(5) b(4) c(3) d(2) e(1)
// "aababcabcdabcde" // "a(5) b(4) c(3) d(2) e(1)" // 我们观察发现 a---5 // b---4 //c----3 // d---2 // e----1 //他是一种键值映射关系的数据 //那我就可以想到双列集合存起来 //然后遍历集合，拼串 //难点就是怎么统计字符出现的个数，以及把这个键值对应关系的数据存到集合中 import org.jcp.xml.dsig.internal.SignerOutputStream; import java.util.HashMap; import java.util.Map; import java.util.Scanner; import java.util.Set; public class MyTest { public static void main(String[] args) { HashMap<Character, Integer> hashMap = new HashMap<>(); Scanner sc = new Scanner(System.in); System.out.println("请输入一段字符串"); String str = sc.nextLine(); //遍历字符串 // char[] chars = str.toCharArray(); //"aababcabcdabcde"; for (int i = 0; i < str.length(); i++) { char ch = str.charAt(i); if (!hashMap.containsKey(ch)) { hashMap.put(ch, 1); } else { //取出旧值 Integer integer = hashMap.get(ch); integer++; hashMap.put(ch, integer);//键相同值覆盖 } } //遍历集合，拼串 StringBuilder sb = new StringBuilder(); Set<Map.Entry<Character, Integer>> entries = hashMap.entrySet(); for (Map.Entry<Character, Integer> entry : entries) { sb.append(entry.getKey()).append("(").append(entry.getValue()).append(")"); } String s = sb.toString(); System.out.println(s); } }结果： 请输入一段字符串 asfddfdsdfsd a(1)s(3)d(5)f(3)
A:案例演示 集合嵌套之HashMap嵌套HashMap 基础班 张三 20 李四 22 就业班 王五 21 赵六 23
案例：
import java.util.HashMap; import java.util.Map; import java.util.Set; public class MyTest { public static void main(String[] args) { /* 基础班 张三 20 李四 22 就业班 王五 21 赵六 23 */ //HashMap 嵌套 HashMap HashMap<String, Integer> jc = new HashMap<>(); jc.put("张三", 20); jc.put("李四", 22); HashMap<String, Integer> jy = new HashMap<>(); jy.put("王五", 21); jy.put("赵六", 23); HashMap<String, HashMap<String, Integer>> maxMap = new HashMap<String, HashMap<String, Integer>>(); maxMap.put("基础班", jc); maxMap.put("就业班", jy); //遍历集合 Set<String> keySet = maxMap.keySet(); for (String s : keySet) { System.out.println(s); HashMap<String, Integer> minMap = maxMap.get(s); Set<String> minKey = minMap.keySet(); for (String s1 : minKey) { System.out.println("\t" + s1 + "\t" + minMap.get(s1)); } System.out.println(); } System.out.println("------------------------"); Set<Map.Entry<String, HashMap<String, Integer>>> entries = maxMap.entrySet(); for (Map.Entry<String, HashMap<String, Integer>> en : entries) { String key = en.getKey(); System.out.println(key); HashMap<String, Integer> minMap = en.getValue(); Set<Map.Entry<String, Integer>> entries1 = minMap.entrySet(); for (Map.Entry<String, Integer> stringIntegerEntry : entries1) { String key1 = stringIntegerEntry.getKey(); Integer value = stringIntegerEntry.getValue(); System.out.println("\t"+key1+" "+value); } System.out.println(); } } }结果： 就业班 王五 21 赵六 23
基础班 李四 22 张三 20
就业班 王五 21 赵六 23
基础班 李四 22 张三 20
案例：
import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Set; public class MyTest2 { public static void main(String[] args) { /** * 三国演义 吕布 周瑜 笑傲江湖 令狐冲 林平之 神雕侠侣 郭靖 杨过 */ // HashMap 嵌套 ArrayList ArrayList<String> sgList = new ArrayList<>(); sgList.add("吕布"); sgList.add("周瑜"); ArrayList<String> xaList = new ArrayList<>(); xaList.add("令狐冲"); xaList.add("林平之"); ArrayList<String> sdList = new ArrayList<>(); sdList.add("郭靖"); sdList.add("杨过"); sdList.add("尹志平"); LinkedHashMap<String, ArrayList<String>> maxMap = new LinkedHashMap<>(); maxMap.put("三国演义", sgList); maxMap.put("笑傲江湖", xaList); maxMap.put("神雕侠侣", sdList); //遍历 /** * 三国演义 吕布 周瑜 笑傲江湖 令狐冲 林平之 神雕侠侣 郭靖 杨过 */ Set<String> keySet = maxMap.keySet(); for (String key : keySet) { System.out.println(key); ArrayList<String> list = maxMap.get(key); for (String s : list) { System.out.println("\t"+s); } System.out.println(); } } }结果： 三国演义 吕布 周瑜
笑傲江湖 令狐冲 林平之
神雕侠侣 郭靖 杨过 尹志平
案例：
import java.util.ArrayList; import java.util.HashMap; import java.util.Map; import java.util.Set; public class MyTest3 { public static void main(String[] args) { //周瑜-- - 小乔 //吕布-- - 貂蝉 // //郭靖-- - 黄蓉 //杨过-- - 小龙女 // //令狐冲-- - 任盈盈 //林平之-- - 岳灵珊 //ArrayList 嵌套 HashMap HashMap<String, String> sgMap = new HashMap<>(); sgMap.put("周瑜", "小乔"); sgMap.put("吕布", "貂蝉"); HashMap<String, String> sdMap = new HashMap<>(); sdMap.put("郭靖", "黄蓉"); sdMap.put("杨过", "小龙女"); HashMap<String, String> xaMap = new HashMap<>(); xaMap.put("令狐冲", "任盈盈"); xaMap.put("林平之", "岳灵珊"); ArrayList<HashMap<String, String>> maxList = new ArrayList<>(); maxList.add(sgMap); maxList.add(sdMap); maxList.add(xaMap); for (HashMap<String, String> map : maxList) { Set<Map.Entry<String, String>> entries = map.entrySet(); for (Map.Entry<String, String> entry : entries) { String key = entry.getKey(); String value = entry.getValue(); System.out.println(key + "-----" + value); } System.out.println(); } } }结果： 吕布-----貂蝉 周瑜-----小乔
杨过-----小龙女 郭靖-----黄蓉
令狐冲-----任盈盈 林平之-----岳灵珊
A:面试题 HashMap和Hashtable的区别: 查看API可以知道 HashMap: 线程不安全,效率高.允许null值和null键 Hashtable: 线程安全 , 效率低.不允许null值和null键 B:案例演示 HashMap和Hashtable的区别
