原Java学习笔记029 - 映射
Posted iflytek
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了原Java学习笔记029 - 映射相关的知识，希望对你有一定的参考价值。
1 package cn.temptation; 2 3 import java.util.HashMap; 4 import java.util.Map; 5 6 public class Sample01 { 7 public static void main(String[] args) { 8 /* 9 * Collection接口及其子接口、实现类 等 称为 单列集合 10 * Map接口及其子接口、实现类等 称为 双列集合 11 * 12 * 接口 Map<K,V>：映射，将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 13 * 14 * Map（映射）由两部分组成：键（Key）和值（Value） 15 * 16 * 特点： 17 * 1、一个映射不能包含重复的键 18 * 2、每个键最多只能映射到一个值 19 * 3、映射中的键值对是无序的 20 * 21 * 理解Map（映射）： 22 * 联想地图，能唯一确定地点使用的是坐标，地图上没有两个相同的坐标 23 * 但是地图上可以有相同的地名，比如不同省份下的区县可能名字相同，但是它们的坐标是不同的 24 * 地图上的坐标就是键，地名就是值 25 * 26 * Map<K,V>接口的常用成员方法： 27 * 1、添加功能 28 * V put(K key, V value) ：将指定的值与此映射中的指定键关联（可选操作）。 29 * 返回：以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null。（如果该实现支持 null 值，则返回 null 也可能表示此映射以前将 null 与 key 关联）。 30 * 31 * 2、删除功能 32 * void clear() ：从此映射中移除所有映射关系（可选操作）。 33 * V remove(Object key) ：如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 34 * 35 * 3、判断功能 36 * boolean containsKey(Object key) ：如果此映射包含指定键的映射关系，则返回 true。 37 * boolean containsValue(Object value) ：如果此映射将一个或多个键映射到指定值，则返回 true。 38 * 39 * boolean isEmpty() ：如果此映射未包含键-值映射关系，则返回 true。 40 * 41 * 4、长度功能 42 * int size() ：返回此映射中的键-值映射关系数。 43 * 44 */ 45 Map<String, String> map = new HashMap<>(); 46 47 System.out.println("map:" + map); // map:{} 48 49 // 1、添加功能 50 // 如果把Map的键值对理解为夫妻的话，那么其put方法可以认为是返回伴侣的前任 51 // System.out.println("map`s put:" + map.put("高祖", "杨开慧")); // map`s put:null 52 // System.out.println("map`s put:" + map.put("高祖", "贺子珍")); // map`s put:杨开慧 53 // System.out.println("map`s put:" + map.put("高祖", "江青")); // map`s put:贺子珍 54 55 map.put("秦皇", "嬴政"); 56 map.put("汉武", "刘彻"); 57 map.put("唐宗", "李世民"); 58 map.put("宋祖", "赵匡胤"); 59 map.put("一代天骄", "成吉思汗"); 60 // 键值对映射关系中，键相同的，通过put添加后显示的是最后的那个键值对或者说是最新的那个键值对 61 map.put("一代天骄", "蒋中正"); 62 63 System.out.println("map:" + map); // map:{汉武=刘彻, 宋祖=赵匡胤, 一代天骄=蒋中正, 唐宗=李世民, 秦皇=嬴政} 64 65 System.out.println("----------------------------------------------------"); 66 67 // 2、删除功能 68 // map.clear(); 69 // System.out.println("map:" + map); // map:{} 70 71 map.remove("唐宗"); 72 System.out.println("map:" + map); // map:{汉武=刘彻, 宋祖=赵匡胤, 一代天骄=蒋中正, 秦皇=嬴政} 73 74 System.out.println("map`s remove:" + map.remove("宋祖")); // map`s remove:赵匡胤 75 System.out.println("map:" + map); // map:{汉武=刘彻, 一代天骄=蒋中正, 秦皇=嬴政} 76 77 System.out.println("map`s remove:" + map.remove("西楚霸王")); // map`s remove:null 78 79 System.out.println("----------------------------------------------------"); 80 81 // 3、判断功能 82 System.out.println("map`s containsKey:" + map.containsKey("秦皇")); // map`s containsKey:true 83 System.out.println("map`s containsKey:" + map.containsKey("西楚霸王")); // map`s containsKey:false 84 85 System.out.println("map`s containsValue:" + map.containsValue("刘彻")); // map`s containsValue:true 86 System.out.println("map`s containsValue:" + map.containsValue("刘秀")); // map`s containsValue:false 87 88 map.clear(); 89 System.out.println("map`s isEmpty:" + map.isEmpty()); // map`s isEmpty:true 90 91 // 4、长度功能 92 System.out.println("map`s size:" + map.size()); // map`s size:0 93 } 94 }
1 package cn.temptation; 2 3 import java.util.Collection; 4 import java.util.HashMap; 5 import java.util.Map; 6 import java.util.Set; 7 8 public class Sample02 { 9 public static void main(String[] args) { 10 /* 11 * Map<K, V>接口的常用成员方法： 12 * 1、获取功能 13 * V get(Object key) ：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 14 * Set<K> keySet() ：返回此映射中包含的键的 Set 视图。 15 * Collection<V> values() ：返回此映射中包含的值的 Collection 视图。 16 */ 17 Map<String, String> map = new HashMap<>(); 18 19 map.put("休斯敦", "火箭"); 20 map.put("金州", "勇士"); 21 map.put("洛杉矶", "湖人"); 22 23 System.out.println(map.get("休斯敦")); // 火箭 24 System.out.println(map.get("金州")); // 勇士 25 System.out.println(map.get("洛杉矶")); // 湖人 26 27 System.out.println("-------------------------------"); 28 29 // key不能重复 30 // 键值对映射关系中，键相同的，通过put添加后显示的是最后的那个键值对或者说是最新的那个键值对 31 map.put("西雅图", "超音速"); 32 map.put("西雅图", "不眠夜"); 33 34 Set<String> set = map.keySet(); 35 36 for (String item : set) { 37 System.out.println(item); 38 } 39 40 System.out.println("-------------------------------"); 41 42 // value可以重复 43 map.put("夏洛特", "黄蜂"); 44 map.put("新奥尔良", "黄蜂"); 45 46 Collection<String> collection = map.values(); 47 48 for (String item : collection) { 49 System.out.println(item); 50 } 51 52 // 注意：取出的值的顺序 和 放入映射的顺序是不一致的，但是取出的值的顺序 和 取出的键的顺序一致 53 } 54 }
1 package cn.temptation; 2 3 import java.util.HashMap; 4 import java.util.Map; 5 import java.util.Map.Entry; 6 import java.util.Set; 7 8 public class Sample03 { 9 public static void main(String[] args) { 10 /* 11 * Map<K, V>接口的常用成员方法： 12 * Set<Map.Entry<K,V>> entrySet() ：返回此映射中包含的映射关系的 Set 视图。 13 * 14 * 接口 Map.Entry<K,V>：映射项（键-值对）。 15 * 16 * Map.Entry<K,V>接口的常用成员方法： 17 * 1、K getKey() ：返回与此项对应的键。 18 * 2、V getValue() ：返回与此项对应的值。 19 */ 20 Map<String, String> map = new HashMap<>(); 21 22 map.put("德玛西亚之力", "盖伦"); 23 map.put("德邦总管", "赵信"); 24 map.put("无极剑圣", "易大师"); 25 26 // 遍历Map 27 28 // 方法1、通过Map接口的keySet方法、get方法 29 Set<String> keySet = map.keySet(); 30 for (String key : keySet) { 31 String value = map.get(key); 32 System.out.println("key:" + key + " <-----> " + "value:" + value); 33 } 34 35 System.out.println("-------------------------------------"); 36 37 // 方法2、通过Map接口的entrySet方法、Entry接口的getKey方法、getValue方法（常用写法） 38 Set<Entry<String,String>> set = map.entrySet(); 39 for (Entry<String, String> entry : set) { 40 String key = entry.getKey(); 41 String value = entry.getValue(); 42 System.out.println("key:" + key + " <-----> " + "value:" + value); 43 } 44 } 45 }
1 package cn.temptation; 2 3 import java.util.HashMap; 4 import java.util.Map; 5 import java.util.Map.Entry; 6 7 public class Sample04 { 8 public static void main(String[] args) { 9 /* 10 * 类 HashMap<K,V>：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。 11 */ 12 Map<String, String> map = new HashMap<>(); 13 14 map.put("中国", "北京"); 15 map.put("美国", "华盛顿"); 16 map.put(null, null); 17 18 // 遍历 19 for (Entry<String, String> entry : map.entrySet()) { 20 String key = entry.getKey(); 21 String value = entry.getValue(); 22 System.out.println("key:" + key + " <-----> " + "value:" + value); 23 } 24 } 25 }
1 package cn.temptation; 2 3 import java.util.HashMap; 4 import java.util.Map; 5 import java.util.Map.Entry; 6 7 public class Sample05 { 8 public static void main(String[] args) { 9 // 需求：在map中存储学生信息（姓名和年龄）及学号，并进行遍历（以学号为key，以学生信息为value） 10 Map<String, Student> map = new HashMap<>(); 11 12 // Map中key这个字符串类型设为学号，通过学号确定唯一性，学生信息作为值 13 map.put("9526", new Student("张三", 20)); 14 map.put("9527", new Student("李四", 18)); 15 map.put("9528", new Student("王五", 22)); 16 // 因为key相同，所以覆盖了前面添加进去的Student对象 17 map.put("9526", new Student("赵六", 16)); 18 19 System.out.println("map:" + map); 20 21 // 遍历映射 22 for (Entry<String, Student> entry : map.entrySet()) { 23 String id = entry.getKey(); 24 Student temp = entry.getValue(); 25 System.out.println("学号为：" + id + "，" + temp.toString()); 26 } 27 } 28 }
1 package cn.temptation; 2 3 import java.util.Collection; 4 import java.util.HashMap; 5 import java.util.Map; 6 import java.util.Set; 7 import java.util.Map.Entry; 8 9 public class Sample06 { 10 // 成员变量 11 private static Map<Student, String> map = new HashMap<>(); 12 13 public static void main(String[] args) { 14 // 需求：在map中存储学生信息（姓名和年龄）及学号，并进行遍历（以学生信息为key，以学号为value） 15 // 问题1：如果我们知道这两个学生对象其实指的是同一个人，该如何处理？ 16 // 答：这样学号就不是判断学生的唯一性的标准，而是学生信息是判定学生唯一的依据 17 18 // 问题2：添加学生信息不同的对象，但是学号相同，也加入到map对象中，想避免学号的重复，该如何处理？ 19 // 答：考虑制作自动学号的生成方法，并且制作学生信息判断去重的方法 20 21 // 因为map中的数据不同的成员方法都要使用，所以考虑提取出去作为成员变量 22 // Map<Student, String> map = new HashMap<>(); 23 24 // Map中key这个字符串类型设为学号，通过学号确定唯一性，学生信息作为值 25 // map.put(new Student("张三", 20), "9526"); 26 // map.put(new Student("李四", 18), "9527"); 27 // map.put(new Student("王五", 22), "9528"); 28 // map.put(new Student("张三", 20), "9520"); // 重写Studengt对象的hashCode方法和equals后，就不会出现两个张三 20岁的学生对象了 29 // map.put(new Student("赵六", 16), "9527"); 30 31 Student student1 = new Student("张三", 20); 32 if (checkStudent(student1)) { 33 map.put(student1, getCurrentID()); 34 } 35 36 Student student2 = new Student("李四", 18); 37 if (checkStudent(student2)) { 38 map.put(student2, getCurrentID()); 39 } 40 41 Student student3 = new Student("王五", 2); 42 if (checkStudent(student3)) { 43 map.put(student3, getCurrentID()); 44 } 45 46 Student student4 = new Student("赵六", 16); 47 if (checkStudent(student4)) { 48 map.put(student4, getCurrentID()); 49 } 50 51 Student student5 = new Student("张三", 20); 52 if (checkStudent(student5)) { 53 map.put(student5, getCurrentID()); 54 } 55 56 System.out.println("map:" + map); 57 58 // 遍历映射 59 for (Entry<Student, String> entry : map.entrySet()) { 60 Student temp = entry.getKey(); 61 String id = entry.getValue(); 62 System.out.println("学号为：" + id + "，" + temp.toString()); 63 } 64 } 65 66 // 获取当前可以使用的学号 67 public static String getCurrentID() { 68 String result = "1"; 69 70 if (map.size() > 0) { 71 72 // 获取所有的学号，存入Collection对象 73 Collection<String> collection = map.values(); 74 75 int max = 0; 76 77 for (String item : collection) { 78 if (Integer.parseInt(item) > max) { 79 max = Integer.parseInt(item); 80 } 81 } 82 83 result = max + 1 + ""; 84 } 85 86 return result; 87 } 88 89 // 判断学生信息是否有重复 90 public static boolean checkStudent(Student student) { 91 boolean flag = true; 92 93 // 获取所有的学生信息，存入Set对象 94 Set<Student> keySet = map.keySet(); 95 96 for (Student item : keySet) { 97 if (item.equals(student)) { 98 flag = false; 99 break; 100 } 101 } 102 103 return flag; 104 } 105 }
1 package cn.temptation; 2 3 // 学生类 4 public class Student { 5 // 成员变量 6 private String name; 7 private int age; 8 9 // 构造函数 10 public Student() { 11 super(); 12 } 13 14 public Student(String name, int age) { 15 super(); 16 this.name = name; 17 this.age = age; 18 } 19 20 // 成员方法 21 public String getName() { 22 return name; 23 } 24 25 public void setName(String name) { 26 this.name = name; 27 } 28 29 public int getAge() { 30 return age; 31 } 32 33 public void setAge(int age) { 34 this.age = age; 35 } 36 37 // 为了唯一判断对象，重写hashCode方法和equals方法 38 @Override 39 public int hashCode() { 40 final int prime = 31; 41 int result = 1; 42 result = prime * result + age; 43 result = prime * result + ((name == null) ? 0 : name.hashCode()); 44 return result; 45 } 46 47 @Override 48 public boolean equals(Object obj) { 49 if (this == obj) 50 return true; 51 if (obj == null) 52 return false; 53 if (getClass() != obj.getClass()) 54 return false; 55 Student other = (Student) obj; 56 if (age != other.age) 57 return false; 58 if (name == null) { 59 if (other.name != null) 60 return false; 61 } else if (!name.equals(other.name)) 62 return false; 63 return true; 64 } 65 66 @Override 67 public String toString() { 68 return "学生 [姓名为：" + name + ", 年龄为：" + age + "]"; 69 } 70 }
1 package cn.temptation; 2 3 import java.util.LinkedHashMap; 4 import java.util.Map; 5 import java.util.Map.Entry; 6 7 public class Sample07 { 8 public static void main(String[] args) { 9 /* 10 * 类 LinkedHashMap<K,V>：Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。 11 * 12 * 特点： 13 * 1、由HashMap保证唯一性 14 * 2、由链表保证有序性 15 */ 16 Map<String, String> map = new LinkedHashMap<>(); 17 18 map.put("无冕之王", "荷兰"); 19 map.put("桑巴军团", "巴西"); 20 map.put("亚洲三流", "中国"); 21 22 for (Entry<String, String> entry : map.entrySet()) { 23 System.out.println("美称：" + entry.getKey() + " <-----> 国家名称：" + entry.getValue()); 24 } 25 } 26 }
1 package cn.temptation; 2 3 import java.util.Map; 4 import java.util.Map.Entry; 5 import java.util.Set; 6 import java.util.TreeMap; 7 8 public class Sample08 { 9 public static void main(String[] args) { 10 /* 11 * 类 TreeMap<K,V>： 12 * 基于红黑树（Red-Black tree）的 NavigableMap 实现。 13 * 该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。 14 * 15 * 用法：类比TreeSet 16 */ 17 Map<String, String> map = new TreeMap<>(); 18 19 map.put("Q", "嬴政"); 20 map.put("H", "刘彻"); 21 map.put("T", "李世民"); 22 map.put("S", "赵匡胤"); 23 24 for (Entry<String, String> entry : map.entrySet()) { 25 String key = entry.getKey(); 26 String value = entry.getValue(); 27 System.out.println(key + " <-----> " + value); 28 } 29 30 System.out.println("------------------------------"); 31 32 Set<String> keySet = map.keySet(); 33 System.out.println("keyset:" + keySet); 34 35 for (String key : keySet) { 36 String value = map.get(key); 37 System.out.println(key + " <-----> " + value); 38 } 39 } 40 }
1 package cn.temptation; 2 3 import java.util.Comparator; 4 import java.util.Map; 5 import java.util.Map.Entry; 6 import java.util.TreeMap; 7 8 public class Sample09 { 9 public static void main(String[] args) { 10 // 需求：使用TreeMap存储学生信息，姓名和年龄相同的学生只能存储一个，排序规则：先按年龄排序，年龄相同按姓名自然排序 11 12 // 思路：姓名和年龄相同的学生只能存储一个，也就是把学生信息作为键；和TreeSet一样，自定义排序规则：通过实现Comparable接口 或 Comparator接口 13 14 Map<Student, String> map = new TreeMap<>(new Comparator<Student>() { 15 @Override 16 public int compare(Student student1, Student student2) { 17 // 先比较年龄 18 int resultAge = student1.getAge() - student2.getAge(); 19 20 // 年龄相同比较姓名 21 int result = (resultAge == 0) ? student1.getName().compareTo(student2.getName()) : resultAge; 22 23 return result; 24 } 25 }); 26 27 map.put(new Student("张三", 20), "9526"); 28 map.put(new Student("李四", 18), "9527"); 29 map.put(new Student("王五", 20), "9528"); 30 map.put(new Student("张三", 20), "9529"); 31 32 for (Entry<Student, String> entry : map.entrySet()) { 33 Student temp = entry.getKey(); 34 String id = entry.getValue(); 35 System.out.println("学号为：" + id + "，" + temp.toString()); 36 } 37 } 38 }
1 package cn.temptation; 2 3 import java.util.ArrayList; 4 import java.util.LinkedHashMap; 5 import java.util.Map; 6 import java.util.Map.Entry; 7 8 public class Sample10 { 9 public static void main(String[] args) { 10 // 需求：选择合适的容器结构，存储并显示数据 11 // 类别：篮球明星前三名：乔丹、邓肯、科比 12 // 类别：足球明星前五名：梅西、C罗、卡卡、伊布、哈维 13 14 // 思路：容器中可以再放入容器 15 16 // 写法1、使用数组存储（注意：不同数组的索引同步） 17 // 声明类别数组 18 String[] arrCategory = { "篮球", "足球" }; 19 // 声明球星数组 20 String[][] arrStar = { { "乔丹", "邓肯", "科比" }, { "梅西", "C罗", "卡卡", "伊布", "哈维" } }; 21 22 // 遍历数组 23 for (int i = 0; i < arrCategory.length; i++) { 24 StringBuffer sb = new StringBuffer(); 25 sb.append("类别：").append(arrCategory[i]).append("中前").append(arrStar[i].length).append("名："); 26 27 for (int j = 0; j < arrStar[i].length; j++) { 28 sb.append(arrStar[i][j]).append("、"); 29 } 30 31 System.out.println(sb.substring(0, sb.length() - 1)); 32 } 33 34 System.out.println("--------------------------------------------------------"); 35 36 // 写法2、使用集合存储（整体使用Map映射，key存为类别，value存为存放了多个球星名字的ArrayList） 37 Map<String, ArrayList<String>> map = new LinkedHashMap<>(); 38 39 ArrayList<String> basketBallList = new ArrayList<>(); 40 basketBallList.add("乔丹"); 41 basketBallList.add("邓肯"); 42 basketBallList.add("科比"); 43 44 map.put("篮球", basketBallList); 45 46 ArrayList<String> soccerList = new ArrayList<>(); 47 soccerList.add("梅西"); 48 soccerList.add("C罗"); 49 soccerList.add("卡卡"); 50 soccerList.add("伊布"); 51 soccerList.add("哈维"); 52 53 map.put("足球", soccerList); 54 55 for (Entry<String, ArrayList<String>> entry : map.entrySet()) { 56 StringBuffer sb = new StringBuffer(); 57 58 String category = entry.getKey(); 59 ArrayList<String> list = entry.getValue(); 60 61 sb.append("类别：").append(category).append("中前").append(list.size()).append("名："); 62 63 for (String item : list) { 64 sb.append(item).append("、"); 65 } 66 67 System.out.println(sb.substring(0, sb.length() - 1)); 68 } 69 } 70 }
1 package cn.temptation; 2 3 import java.util.ArrayList; 4 import java.util.Collection; 5 import java.util.LinkedHashMap; 6 import java.util.Map; 7 import java.util.Map.Entry; 8 9 public class Sample11 { 10 public static void main(String[] args) { 11 // 需求： 12 // 存储并显示2016年NBA东西部决赛 13 // 东部：克利夫兰<----->骑士、明尼苏达<----->森林狼 14 // 西部：休斯敦<----->火箭、金州<----->勇士 15 // 存储并显示2015年NBA东西部决赛 16 // 东部：克利夫兰<----->骑士、亚特兰大<----->老鹰 17 // 西部：洛杉矶<----->湖人、金州<----->勇士 18 19 // 思路：复杂问题分解为若干个简单问题 20 21 Map<String, String> map1 = new LinkedHashMap<>(); 22 map1.put("克利夫兰", "骑士"); 23 map1.put("明尼苏达", "森林狼"); 24 25 Map<String, String> map2 = new LinkedHashMap<>(); 26 map2.put("休斯敦", "火箭"); 27 map2.put("金州", "勇士"); 28 29 Map<String, Map<String, String>> mapArea2016 = new LinkedHashMap<>(); 30 mapArea2016.put("东部", map1); 31 mapArea2016.put("西部", map2); 32 33 // 把2016年的数据封装在对象中 34 Record record2016 = new Record(); 35 record2016.setYear(2016); 36 record2016.setMapArea(mapArea2016); 37 38 Map<String, String> map3 = new LinkedHashMap<>(); 39 map3.put("克利夫兰", "骑士"); 40 map3.put("亚特兰大", "老鹰"); 41 42 Map<String, String> map4 = new LinkedHashMap<>(); 43 map4.put("洛杉矶", "湖人"); 44 map4.put("金州", "勇士"); 45 46 Map<String, Map<String, String>> mapArea2015 = new LinkedHashMap<>(); 47 mapArea2015.put("东部", map3); 48 mapArea2015.put("西部", map4); 49 50 // 把2015年的数据封装在对象中 51 Record record2015 = new Record(); 52 record2015.setYear(2015); 53 record2015.setMapArea(mapArea2015); 54 55 // 创建存储数据记录的集合 56 Collection<Record> collectionNBA = new ArrayList<>(); 57 collectionNBA.add(record2016); 58 collectionNBA.add(record2015); 59 60 StringBuffer sb = new StringBuffer(); 61 62 // 遍历 63 for (Record record : collectionNBA) { 64 sb.append(record.getYear()).append("年NBA东西部决赛：").append("\r\n"); 65 66 for (Entry<String, Map<String, String>> entryArea : record.getMapArea().entrySet()) { 67 sb.append(entryArea.getKey()).append("："); 68 69 Map<String, String> mapCity = entryArea.getValue(); 70 71 StringBuffer sbTemp = new StringBuffer(); 72 73 for (Entry<String, String> entry : mapCity.entrySet()) { 74 sbTemp.append(entry.getKey()).append("<------>").append(entry.getValue()).append("，"); 75 } 76 77 sb.append(sbTemp.substring(0, sbTemp.length() - 1)); 78 sb.append("\r\n"); 79 } 80 81 sb.append("\r\n"); 82 } 83 84 System.out.println(sb); 85 } 86 }
1 package cn.temptation; 2 3 import java.util.LinkedHashMap; 4 import java.util.Map; 5 6 /** 7 * 数据记录类 8 */ 9 public class Record { 10 // 成员变量 11 // 数据记录年份 12 private int year; 13 // 数据记录内容 14 private Map<String, Map<String, String>> mapArea = new LinkedHashMap<>(); 15 16 // 构造函数 17 public Record() { 18 super(); 19 } 20 21 public Record(int year, Map<String, Map<String, String>> mapArea) { 22 super(); 23 this.year = year; 24 this.mapArea = mapArea; 25 } 26 27 // 成员方法 28 public int getYear() { 29 return year; 30 } 31 32 public void setYear(int year) { 33 this.year = year; 34 } 35 36 public Map<String, Map<String, String>> getMapArea() { 37 return mapArea; 38 } 39 40 public void setMapArea(Map<String, Map<String, String>> mapArea) { 41 this.mapArea = mapArea; 42 } 43 44 @Override 45 public String toString() { 46 return "数据 [年份为：" + year + ", 内容为：" + mapArea + "]"; 47 } 48 }
1 package cn.temptation; 2 3 import java.util.LinkedHashMap; 4 import java.util.Map; 5 import java.util.Map.Entry; 6 7 public class Sample12 { 8 public static void main(String[] args) { 9 // 需求：使用集合相关知识统计"javaisgoodisbetterisbestisamazing"中各个字符出现的次数 10 // 显示：字符j：1次、字符a：4次、... 11 12 // 思路： 13 // 1、既然统计的是字符出现的次数，所以把字符串转换为字符数组 14 // 2、创建一个map集合用来存储字符及其出现次数的关系映射，设置key为字符，value为出现次数 15 // 3、遍历字符数组，将得到的字符（key）传递map映射的get方法找到对应出现的次数（value） 16 // A：如果返回值为null，说明map映射中没有该字符及其出现次数的映射关系，那么map中存储下来这个映射关系 17 // B：如果返回值不为null，说明map映射中存在该字符及其出现次数的映射关系，那么将value值+1，再存储下来 18 19 String str = "javaisgoodisbetterisbestisamazing"; 20 char[] arr = str.toCharArray(); 21 Map<Character, Integer> map = new LinkedHashMap<>(); 22 23 // 遍历字符数组 24 for (char item : arr) { 25 // 根据各个字符传入map集合中查找 26 Integer count = map.get(item); 27 28 if (count == null) { 29 // 如果返回值为null，说明map映射中没有该字符及其出现次数的映射关系，那么map中存储下来这个映射关系 30 map.put(item, 1); 31 } else { 32 // 如果返回值不为null，说明map映射中存在该字符及其出现次数的映射关系，那么将value值+1，再存储下来 33 count++; 34 // 注意：具有相同key的键值对，最新的键值对会覆盖之前的键值对 35 map.put(item, count); 36 } 37 } 38 39 // 遍历map集合 40 for (Entry<Character, Integer> entry : map.entrySet()) { 41 Character key = entry.getKey(); 42 Integer value = entry.getValue(); 43 System.out.println("字符" + key + "：" + value + "次"); 44 } 45 } 46 }
1 package cn.temptation; 2 3 import java.util.ArrayList; 4 import java.util.Collection; 5 import java.util.Collections; 6 import java.util.List; 7 8 public class Sample13 { 9 public static void main(String[] args) { 10 /* 11 * 类 Collections： 12 * 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。 13 * 它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。 14 * 15 * Collections类的常用成员方法： 16 * 1、static <T extends Comparable<? super T>> void sort(List<T> list) ：根据元素的自然顺序 对指定列表按升序进行排序。 17 * 18 * 2、static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) ：使用二分搜索法搜索指定列表，以获得指定对象。 19 * 返回：如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。 20 * 插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为 list.size()。 21 * 注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。 22 * 23 * 3、static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) ：根据元素的自然顺序，返回给定 collection 的最大元素。 24 * 25 * 4、static void reverse(List<?> list) ：反转指定列表中元素的顺序。 26 * 27 * 5、static void shuffle(List<?> list) ：使用默认随机源对指定列表进行置换。 28 * 29 */ 30 31 Collection<Integer> collection = new ArrayList<>(); 32 33 collection.add(2); 34 collection.add(3); 35 collection.add(5); 36 collection.add(4); 37 collection.add(1); 38 39 System.out.println("初始集合：" + collection); // 初始集合：[2, 3, 5, 4, 1] 40 41 Collections.sort((List<Integer>)collection); 42 System.out.println("使用排序：" + collection); // 使用排序：[1, 2, 3, 4, 5] 43 44 System.out.println("二分查找：" + Collections.binarySearch((List<Integer>)collection, 2)); // 1 45 System.out.println("二分查找：" + Collections.binarySearch((List<Integer>)collection, 0)); // -1 46 System.out.println("二分查找：" + Collections.binarySearch((List<Integer>)collection, 5)); // 4 47 48 System.out.println("最大值：" + Collections.max(collection)); // 5 49 50 Collections.reverse((List<Integer>)collection); 51 System.out.println("使用反转：" + collection); // 使用反转：[5, 4, 3, 2, 1] 52 53 Collections.shuffle((List<Integer>)collection); 54 System.out.println("随机置换：" + collection); 55 } 56 }
1 package cn.temptation; 2 3 import java.util.ArrayList; 4 import java.util.Collection; 5 import java.util.Collections; 6 import java.util.Comparator; 7 import java.util.List; 8 9 public class Sample14 { 10 public static void main(String[] args) { 11 /* 12 * Collections类的常用成员方法： 13 * 1、static <T> void sort(List<T> list, Comparator<? super T> c) ：根据指定比较器产生的顺序对指定列表进行排序。 14 */ 15 Collection<Student> collection = new ArrayList<>(); 16 17 collection.add(new Student("张三", 20)); 18 collection.add(new Student("李四", 18)); 19 collection.add(new Student("王五", 22)); 20 collection.add(new Student("张飞", 20)); 21 22 // 语法错误：The method sort(List<T>) in the type Collections is not applicable for the arguments (List<Student>) 23 // Collections.sort((List<Student>)collection); 24 25 Collections.sort((List<Student>)collection, new Comparator<Student>() { 26 @Override 27 public int compare(Student student1, Student student2) { 28 // 先比较年龄 29 int resultAge = student1.getAge() - student2.getAge(); 30 31 // 年龄相同再比较姓名 32 int result = (resultAge == 0) ? student1.getName().compareTo(student2.getName()) : resultAge; 33 34 return result; 35 } 36 }); 37 38 // 遍历 39 for (Student item : collection) { 40 System.out.println(item); 41 } 42 } 43 }
1 package cn.temptation; 2 3 import java.util.ArrayList; 4 import java.util.Collection; 5 import java.util.Collections; 6 import java.util.List; 7 8 public class Sample15 { 9 public static void main(String[] args) { 10 // 需求：使用所学集合知识，模拟一副牌（54张）的洗牌、发牌（按照规则制作即可，规则选用一副牌斗地主）和看牌（无序） 11 // 牌：A、2、3、4、5、6、7、8、9、10、J、Q、K、BlackJoker、RedJoker 12 // 花色：♥ ◆ ♠ ♣ 13 14 // 思路： 15 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王） 16 // 2、把牌放入一个容器中 17 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法） 18 // 4、发牌 19 // 5、看牌 20 21 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王） 22 // 创建花色集合 23 Collection<String> colors = new ArrayList<>(); 24 colors.add("♥"); 25 colors.add("◆"); 26 colors.add("♠"); 27 colors.add("♣"); 28 29 // 创建数字集合 30 Collection<String> numbers = new ArrayList<>(); 31 numbers.add("A"); 32 for (int i = 2; i <= 10; i++) { 33 numbers.add(String.valueOf(i)); 34 } 35 numbers.add("J"); 36 numbers.add("Q"); 37 numbers.add("K"); 38 39 // 2、把牌放入一个容器中 40 Collection<String> poker = new ArrayList<>(); 41 42 for (String color : colors) { 43 for (String number : numbers) { 44 poker.add(color.concat(number)); 45 } 46 } 47 48 poker.add("BlackJoker"); 49 poker.add("RedJoker"); 50 51 // System.out.println("一副牌：" + poker); 52 53 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法） 54 Collections.shuffle((List<String>)poker); 55 56 // System.out.println("洗一副牌：" + poker); 57 58 // 4、发牌 59 // 声明剩余底牌数量 60 int remain = 3; 61 // 声明三个玩家对象和一个底牌对象 62 Collection<String> player1 = new ArrayList<>(); 63 Collection<String> player2 = new ArrayList<>(); 64 Collection<String> player3 = new ArrayList<>(); 65 Collection<String> last = new ArrayList<>(); 66 67 for (int i = 0; i < poker.size(); i++) { 68 if (i >= poker.size() - remain) { // 留下底牌 69 last.add(((List<String>)poker).get(i)); 70 } else if (i % 3 == 0) { // 给第一个玩家发牌 71 player1.add(((List<String>)poker).get(i)); 72 } else if (i % 3 == 1) { // 给第二个玩家发牌 73 player2.add(((List<String>)poker).get(i)); 74 } else if (i % 3 == 2) { // 给第三个玩家发牌 75 player3.add(((List<String>)poker).get(i)); 76 } 77 } 78 79 // 5、看牌 80 lookPoker("玩家1", player1); 81 lookPoker("玩家2", player2); 82 lookPoker("玩家3", player3); 83 lookPoker("底牌", last); 84 } 85 86 /** 87 * 看牌方法 88 * @param name 玩家名 89 * @param collection 手牌集合 90 */ 91 public static void lookPoker(String name, Collection<String> collection) { 92 System.out.println(name + "的手牌是："); 93 for (String item : collection) { 94 System.out.print(item + " "); 95 } 96 // 换行 97 System.out.println(); 98 } 99 }
1 package cn.temptation; 2 3 import java.util.ArrayList; 4 import java.util.Collection; 5 import java.util.Collections; 6 import java.util.Comparator; 7 import java.util.List; 8 import java.util.Set; 9 import java.util.TreeSet; 10 11 public class Sample16 { 12 public static void main(String[] args) { 13 // 需求：使用所学集合知识，模拟一副牌（54张）的洗牌、发牌（按照规则制作即可，规则选用一副牌斗地主）和看牌（有序） 14 // 牌：A、2、3、4、5、6、7、8、9、10、J、Q、K、BlackJoker、RedJoker 15 // 花色：♥ ◆ ♠ ♣ 16 // 顺序规则：牌的规则：3 < 4 < 5 < ... < 10 < J < Q < K < A < 2 < BlackJoker < RedJoker 17 // 花色的规则（牌相同时）♥ ♠ ♣ ◆ 18 19 // 思路1： 20 // 在发牌时，通过比较器的使用，直接按规则排列玩家手中牌和底牌 21 22 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王） 23 // 创建花色集合 24 Collection<String> colors = new ArrayList<>(); 25 colors.add("♥"); 26 colors.add("◆"); 27 colors.add("♠"); 28 colors.add("♣"); 29 30 // 创建数字集合 31 Collection<String> numbers = new ArrayList<>(); 32 numbers.add("A"); 33 for (int i = 2; i <= 10; i++) { 34 numbers.add(String.valueOf(i)); 35 } 36 numbers.add("J"); 37 numbers.add("Q"); 38 numbers.add("K"); 39 40 // 2、把牌放入一个容器中 41 Collection<Card> poker = new ArrayList<>(); 42 43 for (String color : colors) { 44 for (String number : numbers) { 45 Card temp = new Card(); 46 temp.setColor(color); 47 temp.setNumber(number); 48 49 poker.add(temp); 50 } 51 } 52 53 poker.add(new Card("", "BlackJoker")); 54 poker.add(new Card("", "RedJoker")); 55 56 // System.out.println("一副牌：" + poker); 57 58 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法） 59 Collections.shuffle((List<Card>)poker); 60 61 // System.out.println("洗一副牌：" + poker); 62 63 // 4、发牌 64 // 声明剩余底牌数量 65 int remain = 3; 66 67 // 声明三个玩家对象和一个底牌对象 68 Comparator<Card> comparator = new CardComparator(); 69 70 Set<Card> player1 = new TreeSet<>(comparator); 71 Set<Card> player2 = new TreeSet<>(comparator); 72 Set<Card> player3 = new TreeSet<>(comparator); 73 Set<Card> last = new TreeSet<>(comparator); 74 75 for (int i = 0; i < poker.size(); i++) { 76 if (i >= poker.size() - remain) { // 留下底牌 77 last.add(((List<Card>)poker).get(i)); 78 } else if (i % 3 == 0) { // 给第一个玩家发牌 79 player1.add(((List<Card>)poker).get(i)); 80 } else if (i % 3 == 1) { // 给第二个玩家发牌 81 player2.add(((List<Card>)poker).get(i)); 82 } else if (i % 3 == 2) { // 给第三个玩家发牌 83 player3.add(((List<Card>)poker).get(i)); 84 } 85 } 86 87 // 5、看牌 88 lookPoker("玩家1", player1); 89 lookPoker("玩家2", player2); 90 lookPoker("玩家3", player3); 91 lookPoker("底牌", last); 92 } 93 94 /** 95 * 看牌方法 96 * @param name 玩家名 97 * @param collection 手牌集合 98 */ 99 public static void lookPoker(String name, Set<Card> collection) { 100 System.out.println(name + "的手牌是："); 101 for (Card item : collection) { 102 System.out.print(item + " "); 103 } 104 // 换行 105 System.out.println(); 106 } 107 }
1 package cn.temptation; 2 3 /** 4 * 牌类 5 */ 6 public class Card { 7 // 成员变量 8 // 花色 9 private String color; 10 // 数字 11 private String number; 12 13 // 构造函数 14 public Card() { 15 super(); 16 } 17 18 public Card(String color, String number) { 19 super(); 20 this.color = color; 21 this.number = number; 22 } 23 24 // 成员方法 25 public String getColor() { 26 return color; 27 } 28 29 public void setColor(String color) { 30 this.color = color; 31 } 32 33 public String getNumber() { 34 return number; 35 } 36 37 public void setNumber(String number) { 38 this.number = number; 39 } 40 41 @Override 42 public String toString() { 43 return color + number; 44 } 45 }
1 package cn.temptation; 2 3 import java.util.Comparator; 4 5 /** 6 * 牌的比较器 7 */ 8 public class CardComparator implements Comparator<Card> { 9 @Override 10 public int compare(Card card1, Card card2) { 11 // 首先比较数字 12 int resultNumber = numberChange(card1.getNumber()) - numberChange(card2.getNumber()); 13 14 // 数字相同时，比较花色 15 int result = (resultNumber == 0) ? colorChange(card1.getColor()) - colorChange(card2.getColor()) : resultNumber; 16 17 return result; 18 } 19 20 /** 21 * 手牌数字转换方法 22 * @param number 手牌数字 23 * @return 对应数字 24 */ 25 public static int numberChange(String number) { 26 int result = 0; 27 28 switch (number) { 29 case "J": 30 result = 11; 31 break; 32 case "Q": 33 result = 12; 34 break; 35 case "K": 36 result = 13; 37 break; 38 case "A": 39 result = 14; 40 break; 41 case "2": 42 result = 15; 43 break; 44 case "BlackJoker": 45 result = 16; 46 break; 47 case "RedJoker": 48 result = 17; 49 break; 50 default: 51 result = Integer.parseInt(number); 52 break; 53 } 54 55 return result; 56 } 57 58 /** 59 * 手牌花色转换方法 60 * @param color 手牌花色 61 * @return 对应数字 62 */ 63 public static int colorChange(String color) { 64 int result = 0; 65 66 switch (color) { 67 case "♥": 68 result = 1; 69 break; 70 case "♠": 71 result = 2; 72 break; 73 case "♣": 74 result = 3; 75 break; 76 case "◆": 77 result = 4; 78 break; 79 default: 80 break; 81 } 82 83 return result; 84 } 85 }
1 package cn.temptation; 2 3 import java.util.ArrayList; 4 import java.util.Collection; 5 import java.util.Collections; 6 import java.util.HashMap; 7 import java.util.List; 8 import java.util.Map; 9 import java.util.Set; 10 import java.util.TreeSet; 11 12 public class Sample17 { 13 public static void main(String[] args) { 14 // 需求：使用所学集合知识，模拟一副牌（54张）的洗牌、发牌（按照规则制作即可，规则选用一副牌斗地主）和看牌（有序） 15 // 牌：A、2、3、4、5、6、7、8、9、10、J、Q、K、BlackJoker、RedJoker 16 // 花色：♥ ◆ ♠ ♣ 17 // 顺序规则：牌的规则：3 < 4 < 5 < ... < 10 < J < Q < K < A < 2 < BlackJoker < RedJoker 18 // 花色的规则（牌相同时）♥ ♠ ♣ ◆ 19 20 // 思路2： 21 // 在发牌阶段进行排序比较麻烦，可以考虑在创建牌的时候，就把顺序订好，54张牌按照大小和花色有一个数字排序（索引） 22 // 后续操作时，洗牌洗的就是这个数字顺序，看牌时每个人的手牌和底牌都按数字顺序排列就好 23 24 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王），花色顺序和数字顺序都定好 25 // 2、牌不但有纸面内容（花色和数字），还有其索引，所以考虑使用Map存储 26 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法） 27 // 4、发牌（发的也是牌的索引） 28 // 5、看牌 29 30 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王），花色顺序和数字顺序都定好 31 // 创建花色集合 32 Collection<String> colors = new ArrayList<>(); 33 colors.add("♥"); 34 colors.add("♠"); 35 colors.add("♣"); 36 colors.add("◆"); 37 38 // 创建数字集合 39 Collection<String> numbers = new ArrayList<>(); 40 for (int i = 3; i <= 10; i++) { 41 numbers.add(String.valueOf(i)); 42 } 43 numbers.add("J"); 44 numbers.add("Q"); 45 numbers.add("K"); 46 numbers.add("A"); 47 numbers.add("2"); 48 49 // 2、牌不但有纸面内容（花色和数字），还有其索引，所以考虑使用Map存储 50 // 创建存放牌的容器 51 Map<Integer, String> poker = new HashMap<>(); 52 // 创建存放牌的索引的容器（伴随着把牌放入Map对象中，索引放入Collection对象中） 53 Collection<Integer> collection = new ArrayList<>(); 54 // 声明牌的索引变量 55 int index = 0; 56 57 // 注意：放牌进入map中顺序，先数字再花色 58 for (String number : numbers) { 59 for (String color : colors) { 60 // 把牌放入Map对象中 61 poker.put(index, color.concat(number)); 62 // 把牌的索引放入Collection对象中 63 collection.add(index); 64 // 创建一张牌，索引自增 65 index++; 66 } 67 } 68 69 // 创建小王 70 poker.put(index, "BlackJoker"); 71 collection.add(index); 72 index++; 73 74 // 创建大王 75 poker.put(index, "RedJoker"); 76 collection.add(index); 77 index++; 78 79 // 遍历map 80 // for (Entry<Integer, String> entry : poker.entrySet()) { 81 // System.out.println(entry.getKey() + "<----->" + entry.getValue()); 82 // } 83 84 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法，洗的是牌的索引集合） 85 Collections.shuffle((List<Integer>)collection); 86 87 // System.out.println("洗一副牌：" + collection); 88 89 // 4、发牌（发的是牌的索引） 90 // 声明剩余底牌数量 91 int remain = 3; 92 93 Set<Integer> player1 = new TreeSet<>(); 94 Set<Integer> player2 = new TreeSet<>(); 95 Set<Integer> player3 = new TreeSet<>(); 96 Set<Integer> last = new TreeSet<>(); 97 98 for (int i = 0; i < poker.size(); i++) { 99 if (i >= poker.size() - remain) { // 留下底牌 100 last.add(((List<Integer>)collection).get(i)); 101 } else if (i % 3 == 0) { // 给第一个玩家发牌 102 player1.add(((List<Integer>)collection).get(i)); 103 } else if (i % 3 == 1) { // 给第二个玩家发牌 104 player2.add(((List<Integer>)collection).get(i)); 105 } else if (i % 3 == 2) { // 给第三个玩家发牌 106 player3.add(((List<Integer>)collection).get(i)); 107 } 108 } 109 110 // 5、看牌（根据键值对中的键去map中找值） 111 lookPoker("玩家1", player1, poker); 112 lookPoker("玩家2", player2, poker); 113 lookPoker("玩家3", player3, poker); 114 lookPoker("底牌", last, poker); 115 } 116 117 /** 118 * 看牌方法 119 * @param name 玩家名 120 * @param collection 手牌集合 121 */ 122 public static void lookPoker(String name, Set<Integer> collection, Map<Integer, String> map) { 123 System.out.println(name + "的手牌是："); 124 125 for (Integer item : collection) { 126 System.out.print(map.get(item) + " "); 127 } 128 129 // 换行 130 System.out.println(); 131 } 132 }
1 package cn.temptation; 2 3 public class Sample18 { 4 public static void main(String[] args) { 5 /* 6 * 集合总结： 7 * Collection接口（单列集合）： 8 * 1、List接口（有序、可重复）： 9 * A、ArrayList：底层实现是数组，查找快速、增删比较慢 10 * B、Vector：向量类，ArrayList是其升级版，底层实现是数组，查找快速、增删比较慢，遍历向量对象可以使用枚举器（Enumeration） 11 * C、LinkedList：底层实现是链表，查找比较慢、增删快速 12 * 13 * 2、Set接口（无序、唯一）： 14 * A、HashSet：底层实现是哈希表、依赖于hashCode()和equals() 15 * B、LinkedHashSet：底层实现是哈希表和链表组成，由哈希表保证元素唯一、由链表保证元素有序 16 * C、TreeSet：支持自然排序和自定义规则排序（实现Comparable接口 或 Comparator接口） 17 * 18 * Map接口（双列集合）： 19 * A、HashMap：底层实现是哈希表、依赖于hashCode()和equals() 20 * B、LinkedHashMap：底层实现是哈希表和链表组成，由哈希表保证元素唯一、由链表保证元素有序 21 * C、TreeMap：支持自然排序和自定义规则排序（实现Comparable接口 或 Comparator接口） 22 * 23 * 24 * 是否需要键值对： 25 * 是：选择Map，键是否需要排序 26 * 是：选择TreeMap 27 * 否：选择HashMap 28 * 否：选择Collection，元素是否需要唯一 29 * 是：选择Set，元素是否需要排序 30 * 是：TreeSet 31 * 否：HashSet 32 * 否：选择List，需要查找快速还是需要增删快速 33 * 查找快速：ArrayList 34 * 增删快速：LinkedList 35 * 36 * 遍历元素： 37 * 1、一般for循环 38 * 2、迭代器（Iterator）或枚举器（Enumeration） 39 * 3、增强型for循环 40 * 41 */ 42 } 43 }
以上是关于原Java学习笔记029 - 映射的主要内容，如果未能解决你的问题，请参考以下文章
[原创]java WEB学习笔记61：Struts2学习之路--通用标签 property，uri，param,set,push,if-else,itertor,sort,date,a标签等(代码片段