首页 > 代码库 > 【原】Java学习笔记029 - 映射

【原】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:null52 //        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:null78         79         System.out.println("----------------------------------------------------");80         81         // 3、判断功能82         System.out.println("map`s containsKey:" + map.containsKey("秦皇"));        // map`s containsKey:true83         System.out.println("map`s containsKey:" + map.containsKey("西楚霸王"));    // map`s containsKey:false84         85         System.out.println("map`s containsValue:" + map.containsValue("刘彻"));    // map`s containsValue:true86         System.out.println("map`s containsValue:" + map.containsValue("刘秀"));    // map`s containsValue:false87         88         map.clear();89         System.out.println("map`s isEmpty:" + map.isEmpty());                    // map`s isEmpty:true90         91         // 4、长度功能92         System.out.println("map`s size:" + map.size());                            // map`s size:093     }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         // 遍历Map27         28         // 方法1、通过Map接口的keySet方法、get方法29         Set<String> keySet = map.keySet();30         for (String key : keySet) {31             String value =http://www.mamicode.com/ 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 =http://www.mamicode.com/ 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 =http://www.mamicode.com/ 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     @Override39     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     @Override48     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     @Override67     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          * 用法:类比TreeSet16          */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 =http://www.mamicode.com/ 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 =http://www.mamicode.com/ 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             @Override16             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     @Override45     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 =http://www.mamicode.com/ 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));        // 145         System.out.println("二分查找:" + Collections.binarySearch((List<Integer>)collection, 0));        // -146         System.out.println("二分查找:" + Collections.binarySearch((List<Integer>)collection, 5));        // 447         48         System.out.println("最大值:" + Collections.max(collection));        // 549         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             @Override27             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、RedJoker12         // 花色:♥ ◆ ♠ ♣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     @Override42     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     @Override10     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          *                         是:选择TreeMap27          *                         否:选择HashMap28          *         否:选择Collection,元素是否需要唯一29          *                         是:选择Set,元素是否需要排序30          *                                         是:TreeSet31          *                                         否:HashSet32          *                         否:选择List,需要查找快速还是需要增删快速33          *                                         查找快速:ArrayList34          *                                         增删快速:LinkedList35          * 36          * 遍历元素:37          * 1、一般for循环38          * 2、迭代器(Iterator)或枚举器(Enumeration)39          * 3、增强型for循环40          * 41          */42     }43 }

 

【原】Java学习笔记029 - 映射