zoukankan      html  css  js  c++  java
  • 【原】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("
    ");
    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("
    ");
    79             }
    80             
    81             sb.append("
    ");
    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中static、final、static final的区别(转)
    Google的JSON风格指南
    Google代码风格指南
    Java中的final关键字(转)
    Java的不定参数(eg:Object...)(转)
    Java Enum枚举的用法(转)
    Java中包装类型和基本类型的使用场景(什么时候使用包装类型)(转)
    Java常用的集合类(转)
    使用Swagger生成Spring Boot REST客户端(支持Feign)(待实践)
    Java搜索引擎选择: Elasticsearch与Solr(转)
  • 原文地址:https://www.cnblogs.com/iflytek/p/6596755.html
Copyright © 2011-2022 走看看