JavaSe总结-18- 集合框架(4)

18.01 Map集合概述和特点
18.02 Map集合的功能概述
18.03 Map集合的基本功能测试
18.04 Map集合的获取功能测试
18.05 Map集合的遍历之键找值
18.06 Map集合的遍历之键值对对象找键和值
18.07 Map集合遍历的两种方式比较图解
18.08 HashMap集合键是Stirng值是String的案例
18.09 HashMap集合键是Student值是String的案例
18.10 LinkedHashMap的概述和使用
18.11 TreeMap集合键是String值是String的案例
18.12 TreeMap集合键是Student值是String的案例
18.13 统计字符串中每个字符出现的次数案例图解
18.14 统计字符串中每个字符出现的次数案例代码实现
18.15 HashMap集合嵌套HashMap集合的案例
18.16 集合多层嵌套的代码体现
18.17 HashMap和Hashtable的区别
18.18 Collections工具类的概述
18.19 Collections工具类的常见方法讲解
18.20 ArrayList存储自定义对象并排序案例
18.21 模拟斗地主洗牌和发牌
18.22 模拟斗地主洗牌和发牌并对牌进行排序的代码实现

18.01 Map集合概述和特点

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

Map接口和Collection接口的不同

1.Map是双列的，Collection是单列的

2.Map的键唯一，Collection的子体系Set是唯一的

3.Map集合的数据结构值针对键有效，跟值无关，Collection集合的数据结构是针对元素有效

18.02 Map集合的功能概述

成员方法:

1.V put(K key,V value):

将指定的值与此映射中的指定键关联（可选操作）。

2.V remove(Object key):

如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

3.void clear():

从此映射中移除所有映射关系（可选操作）。

4.boolean containsKey(Object key):

如果此映射包含指定键的映射关系，则返回 true。

5.boolean containsValue(Object value):

如果此映射将一个或多个键映射到指定值，则返回 true。

6.boolean isEmpty():

如果此映射未包含键-值映射关系，则返回 true。

7.int size():

返回此映射中的键-值映射关系数。

8.V get(Object key)

返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

9.Set<K> keySet()

返回此映射中包含的键的 Set 视图。

10.Collection<V> values()

返回此映射中包含的值的 Collection 视图。

11.Set<Map.Entry<K,V>> entrySet()

返回此映射中包含的映射关系的 Set 视图。

18.03 Map集合的基本功能测试

map.put("001", "旺财");    :第一次存储直接存储元素，返回null

map.put("001", "小强");    :不是第一次存储，用新值将以前的值替换掉，返回以前的值

map.remove("001");     :根据键删除键值对元素，并返回键所对应的值，没有则返回空

18.04 Map集合的获取功能测试

 1 Map<String, String> map = new HashMap<String, String>(); 2          3 map.put("001", "小明"); 4 map.put("002", "旺财"); 5 map.put("003", "小强"); 6 //根据键获取值 7 System.out.println(map.get("002"));//旺财，没有该键返回null 8 System.out.println("-----"); 9 //获取集合中所有键的集合10 Set<String> set = map.keySet();11 for(String key : set)12 {13     System.out.println(key);14 }15 System.out.println("-----");16 //获取集合中所有值的集合17 Collection<String> coll = map.values();18 for(String value : coll)19 {20     System.out.println(value);21 }

18.05 Map集合的遍历之键找值

根据键找值:

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

 1 Map<String, String> map = new HashMap<String, String>(); 2 map.put("001", "小明"); 3 map.put("002", "旺财"); 4 map.put("003", "小强"); 5  6 //获取所有的键 7 Set<String> set = map.keySet(); 8 for(String key : set) 9 {10     //根据键找值11     String value = map.get(key);12     System.out.println(key+":"+value);13 }

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

根据键值对对象找键和值:

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

 1 Map<String, String> map = new HashMap<String, String>(); 2 map.put("001", "小明"); 3 map.put("002", "旺财"); 4 map.put("003", "小强"); 5 //获取所有键值对对象的集合 6 Set<Map.Entry<String, String>> set = map.entrySet(); 7 //遍历键值对对象的集合，获取每一个键值对对象 8 for(Map.Entry<String, String> me : set) 9 {10     //根据键值对对象获取键和值11     String key = me.getKey();12     String value = me.getValue();13     System.out.println(key+":"+value);14 }

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

 

18.08 HashMap集合键是Stirng值是String的案例

HashMap类概述:键是哈希表结构，可以保证键的唯一性

 1 HashMap<String, String> map = new HashMap<String, String>(); 2          3 map.put("001", "小明"); 4 map.put("002", "旺财"); 5 map.put("003", "小强"); 6 map.put("004", "小红"); 7 Set<String> set = map.keySet(); 8 for(String key : set) 9 {10     String value = map.get(key);11     System.out.println(key+"--"+value);12 }

18.09 HashMap集合键是Student值是String的案例

 1 // 创建集合对象 2 HashMap<Student, String> hm = new HashMap<Student, String>(); 3  4 hm.put(new Student("小明",23), "001"); 5 hm.put(new Student("小强",15), "002"); 6 hm.put(new Student("旺财",13), "003"); 7 hm.put(new Student("张三",17), "004"); 8 hm.put(new Student("小强",15), "005"); 9 10 // 遍历11 Set<Student> set = hm.keySet();12 for (Student key : set) 13 {14     String value = hm.get(key);15     System.out.println(key.getName() + "---" + key.getAge() + "---"16             + value);17 }

当键是自定义对象时，需重写hashCode()和equals()方法

18.10 LinkedHashMap的概述和使用

Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。

由哈希表保证键的唯一性

由链表保证键的有序

 1 LinkedHashMap<String, String> hm = new LinkedHashMap<String,String>(); 2          3 // 创建并添加元素 4 hm.put("2345", "hello"); 5 hm.put("1234", "world"); 6 hm.put("3456", "java"); 7 hm.put("1234", "javaee"); 8 hm.put("3456", "android"); 9 10 // 遍历11 Set<String> set = hm.keySet();12 for (String key : set) 13 {14     String value = hm.get(key);15     System.out.println(key + "---" + value);16 }

运行结果:

2345---hello1234---javaee3456---android

 18.11 TreeMap集合键是String值是String的案例

TreeMap类概述:键是红黑树结构，可以保证键的排序和唯一性

 1 // 创建集合对象 2 TreeMap<String, String> tm = new TreeMap<String, String>(); 3  4 // 创建元素并添加元素 5 tm.put("hello", "你好"); 6 tm.put("world", "世界"); 7 tm.put("java", "爪哇"); 8 tm.put("world", "世界2"); 9 tm.put("javaee", "爪哇EE");10 11 // 遍历集合12 Set<String> set = tm.keySet();13 for (String key : set) 14 {15     String value = tm.get(key);16     System.out.println(key + "---" + value);17 }

运行结果:

hello---你好java---爪哇javaee---爪哇EEworld---世界2

 

18.12 TreeMap集合键是Student值是String的案例 

 1 public class Practice  2 { 3     public static void main(String[] args) 4     { 5         // 创建集合对象 6         TreeMap<Student, String> tm = new TreeMap<Student, String>(new Comparator<Student>()  7         { 8             @Override 9             public int compare(Student s1, Student s2) 10             {11                 // 主要条件12                 int num = s1.getAge() - s2.getAge();13                 // 次要条件14                 int num2 = num == 0 ? s1.getName().compareTo(15                         s2.getName()) : num;16                 return num2;17             }18         });19 20         tm.put(new Student("小明",23), "001");21         tm.put(new Student("小强",15), "002");22         tm.put(new Student("旺财",13), "003");23         tm.put(new Student("张三",17), "004");24         tm.put(new Student("小强",15), "005");25         26         Set<Map.Entry<Student, String>> set = tm.entrySet();27         for(Map.Entry<Student, String> me : set)28         {29             Student key = me.getKey();30             String value = me.getValue();31             System.out.println(key.getName()+":"+key.getAge()+":"+value);32         }33     }34 }

运行结果:

旺财:13:003小强:15:005张三:17:004小明:23:001

18.13 统计字符串中每个字符出现的次数案例图解

"aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

18.14 统计字符串中每个字符出现的次数案例代码实现

 1 public class Practice  2 { 3     public static void main(String[] args) 4     { 5         // 定义一个字符串(改进为键盘录入) 6         Scanner sc = new Scanner(System.in); 7         System.out.println("请输入一个字符串:"); 8         String line = sc.nextLine(); 9 10         // 定义一个TreeMap集合11         TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();12         13         //把字符串转换为字符数组14         char[] chs = line.toCharArray();15         16         //遍历字符数组，得到每一个字符17         for(char ch : chs)18         {19             //拿刚才得到的字符作为键到集合中去找值，看返回值20             Integer i =  tm.get(ch);21             22             //是null:说明该键不存在，就把该字符作为键，1作为值存储23             if(i == null)24             {25                 tm.put(ch, 1);26             }27             else 28             {29                 //不是null:说明该键存在，就把值加1，然后重写存储该键和值30                 i++;31                 tm.put(ch,i);32             }33         }34         35         //定义字符串缓冲区变量36         StringBuilder sb=  new StringBuilder();37         38         //遍历集合，得到键和值，进行按照要求拼接39         Set<Character> set = tm.keySet();40         for(Character key : set)41         {42             Integer value = tm.get(key);43             sb.append(key).append("(").append(value).append(")");44         }45         46         //把字符串缓冲区转换为字符串输出47         String result = sb.toString();48         System.out.println("结果:"+result);49     }50 }

 运行结果:

请输入一个字符串:aasdgrfedcsdf结果:a(2)c(1)d(3)e(1)f(2)g(1)r(1)s(2)

18.15 HashMap集合嵌套HashMap集合的案例

 1 public class Practice  2 { 3     public static void main(String[] args) 4     { 5         // 大集合对象 6         HashMap<String, HashMap<String, Integer>> bigMap = new HashMap<String, HashMap<String, Integer>>(); 7  8         // 集合对象1 9         HashMap<String, Integer> hm1 = new HashMap<String, Integer>();10         // 添加元素11         hm1.put("小明", 20);12         hm1.put("小强", 22);13         // 把集合添加到大集合14         bigMap.put("集合1", hm1);15 16         // 集合对象217         HashMap<String, Integer> hm2 = new HashMap<String, Integer>();18         // 添加元素19         hm2.put("旺财", 5);20         hm2.put("张三", 23);21         // 把集合添加到大集合22         bigMap.put("集合2", hm2);23         24         //遍历集合25         Set<String> bigMapset = bigMap.keySet();26         for(String bigMapKey : bigMapset)27         {28             System.out.println(bigMapKey);29             HashMap<String, Integer> value = bigMap.get(bigMapKey);30             Set<String> set = value.keySet();31             for(String s : set)32             {33                 Integer i = value.get(s);34                 System.out.println("\t"+s+":"+i);35             }36         }37     }38 }

运行结果:

集合1    小强:22    小明:20集合2    旺财:5    张三:23

18.16 集合多层嵌套的代码体现

 1 public class Practice  2 { 3     public static void main(String[] args) 4     { 5         // 创建大集合 6         HashMap<String, HashMap<String, ArrayList<Student>>> czbkMap = new HashMap<String, HashMap<String, ArrayList<Student>>>(); 7  8         // 北京校区数据 9         HashMap<String, ArrayList<Student>> bjCzbkMap = new HashMap<String, ArrayList<Student>>();10         ArrayList<Student> array1 = new ArrayList<Student>();11         Student s1 = new Student("林青霞", 27);12         Student s2 = new Student("风清扬", 30);13         array1.add(s1);14         array1.add(s2);15         ArrayList<Student> array2 = new ArrayList<Student>();16         Student s3 = new Student("赵雅芝", 28);17         Student s4 = new Student("武鑫", 29);18         array2.add(s3);19         array2.add(s4);20         bjCzbkMap.put("基础班", array1);21         bjCzbkMap.put("就业班", array2);22         czbkMap.put("北京校区", bjCzbkMap);23 24         // 西安校区数据25         HashMap<String, ArrayList<Student>> xaCzbkMap = new HashMap<String, ArrayList<Student>>();26         ArrayList<Student> array3 = new ArrayList<Student>();27         Student s5 = new Student("范冰冰", 27);28         Student s6 = new Student("刘意", 30);29         array3.add(s5);30         array3.add(s6);31         ArrayList<Student> array4 = new ArrayList<Student>();32         Student s7 = new Student("李冰冰", 28);33         Student s8 = new Student("张志豪", 29);34         array4.add(s7);35         array4.add(s8);36         xaCzbkMap.put("基础班", array3);37         xaCzbkMap.put("就业班", array4);38         czbkMap.put("西安校区", xaCzbkMap);39 40         // 遍历集合41         Set<String> czbkMapSet = czbkMap.keySet();42         for (String czbkMapKey : czbkMapSet) 43         {44             System.out.println(czbkMapKey);45             HashMap<String, ArrayList<Student>> czbkMapValue = czbkMap.get(czbkMapKey);46             Set<String> czbkMapValueSet = czbkMapValue.keySet();47             for (String czbkMapValueKey : czbkMapValueSet) 48             {49                 System.out.println("\t" + czbkMapValueKey);50                 ArrayList<Student> czbkMapValueValue = czbkMapValue.get(czbkMapValueKey);51                 for (Student s : czbkMapValueValue) 52                 {53                     System.out.println("\t\t" + s.getName() + "---"+ s.getAge());54                 }55             }56         }57     }58 }

运行结果:

北京校区    就业班        赵雅芝---28        武鑫---29    基础班        林青霞---27        风清扬---30西安校区    就业班        李冰冰---28        张志豪---29    基础班        范冰冰---27        刘意---30

18.17 HashMap和Hashtable的区别

1:Hashtable和HashMap的区别

Hashtable:线程安全，效率低。不允许null键和null值

HashMap:线程不安全，效率高。允许null键和null值

2:List,Set,Map等接口是否都继承子Map接口?

List，Set不是继承自Map接口，它们继承自Collection接口

Map接口本身就是一个顶层接口

18.18 Collections工具类的概述

Collections类概述:针对集合操作的工具类，都是静态方法

Collection和Collections的区别:

Collection:是单列集合的顶层接口，有子接口List和Set。

Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法

18.19 Collections工具类的常见方法讲解

Collections成员方法

1.public static <T extends Comparable<? super T>> void sort(List<T> list):

根据元素的自然顺序对指定列表按升序进行排序。

2.public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key):

使用二分搜索法搜索指定列表，以获得指定对象。

3.public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll):

根据元素的自然顺序，返回给定 collection 的最大元素。

4.public static void reverse(List<?> list):

反转指定列表中元素的顺序。

5.public static void shuffle(List<?> list):

使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。

例:

 1 public class Practice  2 { 3     public static void main(String[] args) 4     { 5         // 创建集合对象 6         List<Integer> list = new ArrayList<Integer>(); 7  8         // 添加元素 9         list.add(30);10         list.add(20);11         list.add(50);12         list.add(10);13         list.add(40);14 15         System.out.println("原始:" + list);16         //排序  默认情况下是自然顺序17          Collections.sort(list);18          System.out.println("排序:" + list);19         // 二分查找20         System.out.println("查找:"+Collections.binarySearch(list, 30));21         // 最大值22         System.out.println("最大值:"+Collections.max(list));23         // 反转24         Collections.reverse(list);25         System.out.println("反转:" + list);26         //随机置换27         Collections.shuffle(list);28         System.out.println("随机:" + list);29     }30 }

运行结果:

原始:[30, 20, 50, 10, 40]排序:[10, 20, 30, 40, 50]查找:2最大值:50反转:[50, 40, 30, 20, 10]随机:[20, 10, 30, 50, 40]

18.20 ArrayList存储自定义对象并排序案例

 1 public class Practice  2 { 3     public static void main(String[] args) 4     { 5         // 创建集合对象 6         List<Student> list = new ArrayList<Student>(); 7  8         // 创建学生对象 9         Student s1 = new Student("小明", 27);10         Student s2 = new Student("旺财", 30);11         Student s3 = new Student("小强", 28);12         Student s4 = new Student("张三", 29);13 14         // 添加元素对象15         list.add(s1);16         list.add(s2);17         list.add(s3);18         list.add(s4);19 20         // 排序21         // 自然排序必须实现 Comparable 接口22         //Collections.sort(list);23         // 比较器排序24         // 如果同时有自然排序和比较器排序，以比较器排序为主25         Collections.sort(list, new Comparator<Student>() 26         {27             @Override28             public int compare(Student s1, Student s2) 29             {30                 int num = s2.getAge() - s1.getAge();31                 int num2 = num == 0 ? s1.getName().compareTo(s2.getName()): num;32                 return num2;33             }34         });35         // 遍历集合36         for (Student s : list) 37         {38             System.out.println(s.getName() + "---" + s.getAge());39         }40     }41 }

运行结果:

旺财---30张三---29小强---28小明---27

18.21 模拟斗地主洗牌和发牌

模拟斗地主洗牌和发牌

分析:

A:创建一个牌盒、B:装牌、C:洗牌、D:发牌、E:看牌

 1 public class Practice  2 { 3     public static void main(String[] args) 4     { 5         // 创建一个牌盒 6         ArrayList<String> array = new ArrayList<String>(); 7  8         // 定义一个花色数组 9         String[] colors = { "♠", "♥", "♣", "♦" };10         // 定义一个点数数组11         String[] numbers = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10",12                 "J", "Q", "K" };13         // 装牌14         for (String color : colors) 15         {16             for (String number : numbers) 17             {18                 array.add(color.concat(number));19             }20         }21         array.add("小王");22         array.add("大王");23 24         // 洗牌25         Collections.shuffle(array);26 27         // System.out.println("array:" + array);28 29         // 发牌30         ArrayList<String> player1 = new ArrayList<String>();31         ArrayList<String> player2 = new ArrayList<String>();32         ArrayList<String> player3 = new ArrayList<String>();33         ArrayList<String> diPai = new ArrayList<String>();34 35         for (int x = 0; x < array.size(); x++) 36         {37             if (x >= array.size() - 3) 38             {39                 diPai.add(array.get(x));40             } 41             else if (x % 3 == 0) 42             {43                 player1.add(array.get(x));44             } 45             else if (x % 3 == 1) 46             {47                 player2.add(array.get(x));48             } 49             else if (x % 3 == 2) 50             {51                 player3.add(array.get(x));52             }53         }54 55         // 看牌56         lookPoker("玩家1", player1);57         lookPoker("玩家2", player2);58         lookPoker("玩家3", player3);59 60         lookPoker("底牌", diPai);61     }62 63     public static void lookPoker(String name, ArrayList<String> array) 64     {65         System.out.print(name + "的牌是:");66         for (String s : array) 67         {68             System.out.print(s + " ");69         }70         System.out.println();71     }72 }

运行结果:

玩家1的牌是:♦10 ♥4 ♠K ♠5 ♦6 ♥K ♦8 ♥2 ♥3 ♣8 ♣3 ♣4 ♦7 ♠Q ♣10 ♠3 ♠6 玩家2的牌是:♦9 ♦5 ♦A ♣5 ♦3 ♥8 ♣2 ♥J ♦J ♥5 ♦4 ♠9 ♠10 小王♣A ♥Q ♥7 玩家3的牌是:♠A ♣6 ♦2 ♦K ♣9 ♣K ♣7 ♦Q ♠4 ♥9 ♠7 大王♣Q ♥10 ♠8 ♣J ♠2 底牌的牌是:♥A ♥6 ♠J 

18.22 模拟斗地主洗牌和发牌并对牌进行排序的代码实现

思路:

A:创建一个HashMap集合

B:创建一个ArrayList集合

C:创建花色数组和点数数组

D:从0开始往HashMap里面存储编号，并存储对应的牌，同时往ArrayList里面存储编号即可。

E:洗牌(洗的是编号)

F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)

G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)

 1 public class Practice  2 { 3     public static void main(String[] args) 4     { 5         // 创建一个HashMap集合 6         HashMap<Integer, String> hm = new HashMap<Integer, String>(); 7  8         // 创建一个ArrayList集合 9         ArrayList<Integer> array = new ArrayList<Integer>();10 11         // 创建花色数组和点数数组12         // 定义一个花色数组13         String[] colors = { "♠", "♥", "♣", "♦" };14         // 定义一个点数数组15         String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",16                 "K", "A", "2", };17 18         // 从0开始往HashMap里面存储编号，并存储对应的牌,同时往ArrayList里面存储编号即可。19         int index = 0;20 21         for (String number : numbers) 22         {23             for (String color : colors) 24             {25                 String poker = color.concat(number);26                 hm.put(index, poker);27                 array.add(index);28                 index++;29             }30         }31         hm.put(index, "小王");32         array.add(index);33         index++;34         hm.put(index, "大王");35         array.add(index);36 37         // 洗牌(洗的是编号)38         Collections.shuffle(array);39 40         // 发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)41         TreeSet<Integer> player1 = new TreeSet<Integer>();42         TreeSet<Integer> player2 = new TreeSet<Integer>();43         TreeSet<Integer> player3 = new TreeSet<Integer>();44         TreeSet<Integer> diPai = new TreeSet<Integer>();45 46         for (int x = 0; x < array.size(); x++) 47         {48             if (x >= array.size() - 3) 49             {50                 diPai.add(array.get(x));51             } else if (x % 3 == 0) 52             {53                 player1.add(array.get(x));54             } else if (x % 3 == 1) 55             {56                 player2.add(array.get(x));57             } else if (x % 3 == 2) 58             {59                 player3.add(array.get(x));60             }61         }62 63         // 看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)64         lookPoker("玩家1", player1, hm);65         lookPoker("玩家2", player2, hm);66         lookPoker("玩家3", player3, hm);67         lookPoker("底牌", diPai, hm);68     }69 70     // 写看牌的功能71     public static void lookPoker(String name, TreeSet<Integer> ts,72             HashMap<Integer, String> hm) 73     {74         System.out.print(name + "的牌是:");75         for (Integer key : ts) 76         {77             String value = hm.get(key);78             System.out.print(value + " ");79         }80         System.out.println();81     }82 }

 运行结果:

玩家1的牌是:♠3 ♦3 ♥4 ♣4 ♥5 ♣5 ♠6 ♣8 ♥9 ♦10 ♥J ♣J ♦Q ♣A ♠2 ♣2 大王玩家2的牌是:♠5 ♦5 ♣7 ♦7 ♠9 ♥10 ♦J ♠Q ♣Q ♠K ♣K ♠A ♥A ♦A ♥2 ♦2 小王玩家3的牌是:♥3 ♣3 ♠4 ♦4 ♥6 ♣6 ♠7 ♥7 ♥8 ♦8 ♣9 ♠10 ♣10 ♠J ♥Q ♥K ♦K 底牌的牌是:♦6 ♠8 ♦9