原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标签等(代码片段

Android JNI学习笔记-数据类型映射以及native调用java

原Java学习笔记013 - 阶段测试

Java学习笔记24-MyBatis框架

原Java学习笔记010 - 数组

原Java学习笔记005 - 流程控制