Java学习总结--036Map集合+HashMap和Hashtable的区别+Collections(集合工具类)

1.Map集合概述和特点

Java 为了我们更加方便的去操作，这种键值映射关系的数据，给我们提供了另外一种集合叫做Map集合。 Map<K,V>将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 HashMap, Hashtable, LinkedHashMap TreeMap Properties,

A.需求: 根据学号获取学生姓名

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, } }

B.Map接口概述 将键映射到值的对象 一个映射不能包含重复的键 每个键最多只能映射到一个值

C:Map接口和Collection接口的不同 Map是双列的,Collection是单列的; Map的键唯一,Collection的子体系Set是唯一的; Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效;

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); } } 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); } }

2.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()：返回集合中的键值对的对数

3.Map集合的遍历之键找值

键找值思路： 获取所有键的集合; 遍历键的集合，获取到每一个键; 根据键找值;

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); } } } 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; } }

4.Map集合的遍历之键值对对象找键和值

键值对对象找键和值思路： 获取所有键值对对象的集合 遍历键值对对象的集合，获取到每一个键值对对象 根据键值对对象找键和值

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"); } } 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); } }

5.Map集合遍历的两种方式比较

Map集合遍历的两种方式比较

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)); } } }

6.HashMap集合键是Stirng值是String的案例

HashMap 允许插入null键 null值 案例演示: HashMap集合键是Stirng值是String的案例

public class MyTest { public static void main(String[] args) { HashMap 此实现不是同步的。线程不安效率高 //基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作， //并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。） // Hashtable 不允许使用null值null键，线程安全效率低 //HashMap<String, String> map = new HashMap<>(); //map.put(null,null); Hashtable<String, String> hashtable = new Hashtable<>(); //hashtable.put(null,"abc"); //hashtable.put("abc",null); //hashtable.put(null,null); } }

7.LinkedHashMap的概述和使用

A:LinkedHashMap的概述: Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序; B:LinkedHashMap的特点： 底层的数据结构是链表和哈希表 元素有序 并且唯一; 元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证; Map集合的数据结构只和键有关;

8.TreeMap集合键是String值是String的案例

TreeMap 键不允许插入null; TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性 ; 排序分为自然排序和比较器排序 ; 线程是不安全的效率比较高;

9.HashMap集合键是String值是Student的案例

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"); } } 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); } }

10.统计字符串中每个字符出现的次数

案例演示: 需求：统计字符串中每个字符出现的次数 “aababcabcdabcde”,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

public class MyTest { public static void main(String[] args) { //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 //他是一种键值映射关系的数据 //那我就可以想到双列集合存起来 //然后遍历集合，拼串 //难点就是怎么统计字符出现的个数，以及把这个键值对应关系的数据存到集合中 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); } }

11.集合嵌套之HashMap嵌套HashMap

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(); } } }

12.集合嵌套之HashMap嵌套ArrayList

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(); } } }

13.集合嵌套之ArrayList嵌套HashMap

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(); } } }

14.HashMap和Hashtable的区别

HashMap和Hashtable的区别: 查看API可以知道 HashMap: 线程不安全,效率高.允许null值和null键 Hashtable: 线程安全 , 效率低.不允许null值和null键

public class MyTest { public static void main(String[] args) { HashMap 此实现不是同步的。线程不安效率高 //基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作， //并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。） // Hashtable 不允许使用null值null键，线程安全效率低 //HashMap<String, String> map = new HashMap<>(); //map.put(null,null); Hashtable<String, String> hashtable = new Hashtable<>(); //hashtable.put(null,"abc"); //hashtable.put("abc",null); //hashtable.put(null,null); } }

15.Collections工具类的概述和常见方法讲解

A:Collections类概述: 针对集合操作 的工具类 B:Collections成员方法 public static void sort(List list): 排序,默认按照自然顺序 public static int binarySearch(List<?> list,T key): 二分查找 public static T max(Collection<?> coll): 获取最大值 public static void reverse(List<?> list): 反转 public static void shuffle(List<?> list): 随机置换

public class MyTest2 { public static void main(String[] args) { // Collection Set List // A: // Collections类概述: // 针对集合操作 的工具类 // B: // 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):随机置换 ArrayList<Integer> list = new ArrayList<>(); list.add(100); list.add(1002); list.add(1030); list.add(1050); list.add(100); //list.sort(); Collections.sort(list); //Collections.sort(list, new Comparator<Integer>() { // @Override // public int compare(Integer o1, Integer o2) { // return 0; // } //}); //System.out.println(list); int i = Collections.binarySearch(list, 1050); System.out.println(i); System.out.println(Collections.max(list)); System.out.println(Collections.min(list)); Collections.reverse(list);//反转集合中的元素 System.out.println(list); Collections.shuffle(list);//随机打乱集合中元素的顺序 System.out.println(list); } }