1.Map集合概述

  • Interface Map K:键的类型; V:值的类型
  • 将键映射到值的对象;不能包含重复的键;每个键可以映射到最多一个值

举例:学生的学号和姓名

创建Map集合的对象

  • 多态的方式
  • 具体的实现类HashMap
  1. package com.study_01;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class MapDemo01 {
  7.     public static void main(String[] args) {
  8.         // 创建集合对象
  9.         Map<String,String> map = new HashMap<>();
  11.         //V put (K key, V value) 将指定的值与该映射中的指定键相关联
  12.         map.put("xiaoZ001","林青霞");
  13.         map.put("xiaoZ002","张曼玉");
  14.         map.put("xiaoZ003","王祖贤");
  15.         map.put("xiaoZ003","柳岩");
  17.         // 输出集合对象
  18.         System.out.println(map);
  19.     }
  20. }

2.Map集合的基本功能

Map - 图1

  1. package com.study_01;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class MapDemo02 {
  7.     public static void main(String[] args) {
  8.         // 创建集合对象
  9.         Map<String,String> map = new HashMap<>();
  11.         //V put (K key, V value) 将指定的值与该映射中的指定键相关联
  12.         map.put("张无忌","赵敏");
  13.         map.put("郭靖","黄蓉");
  14.         map.put("杨过","小龙女");
  16.         // 根据键删除键值对元素
  17. //        System.out.println(map.remove("郭靖"));
  18. //        System.out.println(map.remove("郭襄"));
  20.         // 移除所有键值对元素
  21. //        map.clear();
  23. //        判断集合是否包含指定的键
  24. //        System.out.println(map.containsKey("郭靖"));
  25. //        System.out.println(map.containsKey("郭襄"));
  27.         // 判断集合是否为空
  28. //        System.out.println(map.isEmpty());
  30.         // 集合长度
  31.         System.out.println(map.size());
  33.         // 输出集合
  34.         System.out.println(map);
  35.     }
  36. }

3.Map集合的获取功能

Map - 图2

  1. package com.study_01;
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Set;
  8. public class MapDemo03 {
  9.     public static void main(String[] args) {
  10.         // 创建集合对象
  11.         Map<String, String> map = new HashMap<>();
  13.         // 添加元素
  14.         map.put("张无忌", "赵敏");
  15.         map.put("郭靖", "黄蓉");
  16.         map.put("杨过", "小龙女");
  18.         // 根据键获取值
  19. //        System.out.println(map.get("张无忌"));
  20. //        System.out.println(map.get("张三丰"));
  22.         // Set<K> keySet() : 获取所有键的值
  23. //        Set<String> keySet = map.keySet();
  24. //        for (String i : keySet){
  25. //            System.out.println(i);
  26. //        }
  28.         // 获取所有值的集合
  29.         Collection<String> values = map.values();
  30.         for (String i : values) {
  31.             System.out.println(i);
  32.         }
  33.     }
  34. }

4.Map集合的遍历(方式1)

我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合

遍历思路

  • 把所有的丈夫给集中起来
  • 遍历丈夫的集合，获取到每一个丈夫
  • 根据丈夫去找对应的妻子

转换为Map集合中的操作:

  • 获取所有键的集合。 用keySet0方法实现
  • 遍历键的集合，获取到每一个键。用增强for实现
  • 根据键去找值。用get(Object key)方法实现
  1. package com.study_02;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Set;
  7. public class MapDemo01 {
  8.     public static void main(String[] args) {
  9.         // 创建集合对象
  10.         Map<String,String> map = new HashMap<>();
  12.         // t添加元素
  13.         map.put("张无忌","赵敏");
  14.         map.put("郭靖","黄蓉");
  15.         map.put("杨过","小龙女");
  17.         // 获取所有键的集合,用keySet()实现
  18.         Set<String> keySet = map.keySet();
  19.         // 遍历键的耳机和,获取到每一个键,用增强for实现
  20.         for (String key : keySet) {
  21.             String value = map.get(key);
  22.             System.out.println(key+","+value);
  23.         }
  24.     }
  25. }

5.Map集合的遍历(方式2)

我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个妻对的集合

遍历思路

  • 获取所有结婚证的集合
  • 遍历结婚证的集合，得到每一个结婚证
  • 根据结婚证获取丈夫和妻子

转换为Map集合中的操作:

  • 获取所有键值对对象的集合
    • Set > entrySet(:获取所有键值对对象的集合
  • 遍历键值对对象的集合，得到每一个键值对对象
    • 用增强for实现，得到每一个Map.Entry
  • 根据键值对对象获取键和值
    • 用getKey()得到键
    • 用getValue()得到值 ```java package com.study_02;

import java.util.HashMap; import java.util.Map; import java.util.Set;

public class MapDemo02 { public static void main(String[] args) { // 创建集合对象 Map map = new HashMap<>();

  1.     // t添加元素
  2.     map.put("张无忌","赵敏");
  3.     map.put("郭靖","黄蓉");
  4.     map.put("杨过","小龙女");
  6.     // 获取所有键值对对象的集合
  7.     Set<Map.Entry<String,String>> entrySet = map.entrySet();
  8.     // 遍历键值对对象的集合，得到每一个键值对对象
  9.     for (Map.Entry<String,String> me : entrySet) {
  10.         String key = me.getKey();
  11.         String value = me.getValue();
  12.         System.out.println(key+"," + value);
  13.     }
  16.     // 根据键值对对象获取键和值
  19. }

}

  2. <a name="7c04953f"></a>
  3. ## 6.案例
  5. 案例: HashMap集合存储学生对象并遍历
  7. 需求:创建一个HashMap集合, 键是学号(String), 值是学生对象(Student)。存储三E个键值对元素,并遍历
  9. ```java
  10. package com.study_03;
  12. import java.util.Objects;
  14. public class Student {
  15.     private String name;
  16.     private int age;
  18.     public Student(String name, int age) {
  19.         this.name = name;
  20.         this.age = age;
  21.     }
  23.     public Student() {
  24.     }
  26.     public String getName() {
  27.         return name;
  28.     }
  30.     public void setName(String name) {
  31.         this.name = name;
  32.     }
  34.     public int getAge() {
  35.         return age;
  36.     }
  38.     public void setAge(int age) {
  39.         this.age = age;
  40.     }
  42.     @Override
  43.     public String toString() {
  44.         return "Student{" +
  45.                 "name='" + name + '\'' +
  46.                 ", age=" + age +
  47.                 '}';
  48.     }
  49. }
  1. package com.study_03;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Set;
  7. public class HashMapDemo {
  8.     public static void main(String[] args) {
  9.         // 创建HashMap集合对象
  10.         HashMap<String,Student> hm = new HashMap<>();
  12.         // 创建学生对象
  13.         Student s1 = new Student("林青霞",30);
  14.         Student s2 = new Student("张曼玉",35);
  15.         Student s3 = new Student("王祖贤",33);
  17.         // 把学生添加到集合
  18.         hm.put("stu001",s1);
  19.         hm.put("stu002",s2);
  20.         hm.put("stu003",s3);
  22.         // 键找值
  23.         Set<String> set = hm.keySet();
  24.         for (String key : set) {
  25.             Student value = hm.get(key);
  26.             System.out.println(key+","+value);
  27.         }
  28.         System.out.println("---------");
  30.         Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
  31.         for (Map.Entry<String, Student> me : entrySet) {
  32.             String key = me.getKey();
  33.             Student value = me.getValue();
  34.             System.out.println();
  35.         }
  36.     }}

7.案例

需求:创建一个HashMap集合,键是学生对象(Student), 值是居住地(String)。存储多个键值对元素，并遍历。

要求保证键的唯一性: 如果学生对象的成员变量值相同，我们就认为是同一个对象

  1. package com.study_04;
  3. import java.util.Objects;
  5. public class Student {
  6.     private String name;
  7.     private int age;
  9.     public Student(String name, int age) {
  10.         this.name = name;
  11.         this.age = age;
  12.     }
  14.     public Student() {
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public int getAge() {
  26.         return age;
  27.     }
  29.     public void setAge(int age) {
  30.         this.age = age;
  31.     }
  34.     @Override
  35.     public boolean equals(Object o) {
  36.         if (this == o) return true;
  37.         if (o == null || getClass() != o.getClass()) return false;
  38.         Student student = (Student) o;
  39.         return age == student.age && Objects.equals(name, student.name);
  40.     }
  42.     @Override
  43.     public int hashCode() {
  44.         return Objects.hash(name, age);
  45.     }
  47.     @Override
  48.     public String toString() {
  49.         return "Student{" +
  50.                 "name='" + name + '\'' +
  51.                 ", age=" + age +
  52.                 '}';
  53.     }
  54. }
  1. package com.study_04;
  3. import java.util.HashMap;
  4. import java.util.Set;
  6. public class HashMapDemo {
  7.     public static void main(String[] args) {
  8.         // 创建HashMap集合对象
  9.         HashMap<Student,String > hm = new HashMap<>();
  11.         // 创建学生对象
  12.         Student s1 = new Student("林青霞",30);
  13.         Student s2 = new Student("张曼玉",35);
  14.         Student s3 = new Student("王祖贤",33);
  15.         Student s4 = new Student("王祖贤",33);
  17.         // 把学生添加到集合
  18.         hm.put(s1,"西安");
  19.         hm.put(s2,"武汉");
  20.         hm.put(s3,"郑州");
  22.         hm.put(s4,"北京");
  24.         // 遍历集合
  25.         Set<Student> set = hm.keySet();
  26.         for (Student key : set) {
  27.             String value = hm.get(key);
  28.             System.out.println(key+","+value);
  29.         }
  30.     }
  31. }

8.集合嵌套值ArrayList嵌套HashMap

需求:创建一个ArrayList集合, 存储三个元素，每一个元素都是HashMap, 每一个HashMap的键和值都是String, 并遍历

  1. package com.study_05;
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Set;
  7. public class ArrayListCludeHashMapDemo {
  8.     public static void main(String[] args) {
  9.         // 创建ArrayLis集合
  10.         ArrayList<HashMap<String, String>> array = new ArrayList<>();
  12.         // 创建HashMap集合
  13.         HashMap<String, String> hm1 = new HashMap<>();
  14.         hm1.put("孙策", "大桥");
  15.         hm1.put("周瑜", "小乔");
  16.         array.add(hm1);
  18.         HashMap<String, String> hm2 = new HashMap<>();
  19.         hm2.put("郭靖", "黄蓉");
  20.         hm2.put("杨过", "小龙女");
  21.         array.add(hm2);
  23.         HashMap<String, String> hm3 = new HashMap<>();
  24.         hm3.put("孙策3", "大桥3");
  25.         hm3.put("周瑜3", "小乔3");
  26.         array.add(hm3);
  28.         for (HashMap<String,String> hm : array) {
  29.             Set<String> keySetset = hm.keySet();
  30.             for (String key : keySetset) {
  31.                 String value = hm.get(key);
  32.                 System.out.println(key + "," + value);
  33.             }
  34.         }
  35.     }
  36. }

9.HashMap集合存储ArrayList集合并遍历

需求：创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList，每一个ArrayList的元素是String，并遍历

  1. package com.study_05;
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Set;
  7. public class HashMapDemo {
  8.     public static void main(String[] args) {
  9.         // 创建HashMap集合
  10.         HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
  12.         // 创建ArrayLis集合,并添加元素
  13.         ArrayList<String> sgyy = new ArrayList<>();
  14.         sgyy.add("诸葛亮");
  15.         sgyy.add("赵云");
  16.         // 把ArrayList作为元素添加到Has和Map集合
  17.         hm.put("三国演义", sgyy);
  19.         ArrayList<String> xyj = new ArrayList<>();
  20.         xyj.add("唐僧");
  21.         xyj.add("孙悟空");
  22.         // 把ArrayList作为元素添加到Has和Map集合
  23.         hm.put("西游记", xyj);
  25.         ArrayList<String> shz = new ArrayList<>();
  26.         shz.add("武松");
  27.         shz.add("鲁智深");
  28.         // 把ArrayList作为元素添加到Has和Map集合
  29.         hm.put("水浒传", shz);
  31.         // 遍历HashMap
  32.         Set<String> keySet = hm.keySet();
  33.         for (String key : keySet) {
  34.             System.out.println(key);
  35.             ArrayList<String> value = hm.get(key);
  36.             for (String s : value) {
  37.                 System.out.println("\t"+s);
  38.             }
  39.         }
  40.     }
  41. }

10.案例：统计字符串中每个字符出现的次数

需求：键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。
举例：键盘录入“aababcabcdabcde”在控制台输出：“a（5）b（4）c（3）d（2）e（1）”

  1. package com.study_06;
  3. import java.util.HashMap;
  4. import java.util.Scanner;
  5. import java.util.Set;
  6. import java.util.TreeMap;
  9. public class HashMapDemo {
  10.     public static void main(String[] args) {
  11.         // 键盘录入数据
  12.         Scanner sc = new Scanner(System.in);
  13.         System.out.print("请输入一个字符串:");
  14.         String line = sc.nextLine();
  16.         // 创建HashMap集合,键是Character,值是Integer
  17. //        HashMap<Character, Integer> hm = new HashMap<>();
  18.         TreeMap<Character, Integer> hm = new TreeMap<>(); // 按键自然排序
  21.         // 遍历字符串
  22.         for (int i = 0; i < line.length(); i++) {
  23.             char key = line.charAt(i);
  25.             Integer value = hm.get(key);
  27.             if (value == null) {
  28.                 // /如果返回值是nulL：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
  29.                 hm.put(key, 1);
  30.             } else {
  31.                 // /如果返回值不是nulL：说明该字符在HashMap集合中存在，把该值加1，然后重新存储该事符和对应的值
  32.                 hm.put(key, value + 1);
  33.             }
  34.         }
  35.         //遍历HashMap集合，得到键和值，按照要求进行拼接
  36.         StringBuilder sb = new StringBuilder();
  37.         Set<Character> keySet = hm.keySet();
  38.         for (Character key : keySet) {
  39.             Integer value = hm.get(key);
  40.             sb.append(key).append("(").append(value).append(")");
  41.         }
  42.         String result = sb.toString();
  44.         System.out.println(result);
  45.     }
  46. }

11.Collections概述和使用

Collections类的概述

  • 是针对集合操作的工具类

Collections类的常用方法

  • public static> void sort（List< T > list）：将指定的列表按升序排序
  • public static void reverse（List< ？>list）：反转指定列表中元素的顺序e
  • public static void shuffle（List< ？>list）：使用默认的随机源随机排列指定的列表
  1. package com.study_01;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.Collections;
  6. import java.util.List;
  8. public class CollectionDemo01 {
  9.     public static void main(String[] args) {
  10.         // 创建集合对象
  11.         List<Integer> list = new ArrayList<>();
  13.         //添加元素
  14.         list.add(30);
  15.         list.add(50);
  16.         list.add(20);
  17.         list.add(100);
  19.         // public static<T extends Comparable<？super T>> void sort（List< T > list）：将指定的列表按升序排序
  20. //        Collections.sort(list);
  22. //        Collections.reverse(list);
  24.         Collections.shuffle(list);
  25.         System.out.println(list);
  26.     }
  27. }
  1. package com.study_01;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.Collections;
  6. import java.util.Comparator;
  8. public class CollectionDemo02 {
  9.     public static void main(String[] args) {
  10.         // 创建ArrayList集合对象
  11.         ArrayList<Student> array = new ArrayList<>();
  13.         // 创建学生对象
  14.         Student s1 = new Student("lin",30);
  15.         Student s2 = new Student("zhang",35);
  16.         Student s3 = new Student("wang",33);
  17.         Student s4 = new Student("liu",33);
  19.         // 把学生添加到集合
  20.         array.add(s1);
  21.         array.add(s2);
  22.         array.add(s3);
  23.         array.add(s4);
  24. //sort (List<T> list,Comparator<? super T>c)
  25.         Collections.sort(array, new Comparator<Student>() {
  26.             @Override
  27.             public int compare(Student s1, Student s2) {
  28.                 int num = s1.getAge() - s2.getAge();
  29.                 int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
  30.                 return num2;
  31.             }
  32.         });
  34.         for (Student s : array) {
  35.             System.out.println(s);
  36.         }
  37.     }
  38. }
  1. package com.study_01;
  3. public class Student {
  4.     private String name;
  5.     private int age;
  7.     public Student(String name, int age) {
  8.         this.name = name;
  9.         this.age = age;
  10.     }
  12.     public Student() {
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Student{" +
  34.                 "name='" + name + '\'' +
  35.                 ", age=" + age +
  36.                 '}';
  37.     }
  38. }

12.ArrayList学生案例并排序

  1. Collections.sort(array, new Comparator<Student>() {
  2.     @Override
  3.     public int compare(Student s1, Student s2) {
  4.         int num = s1.getAge() - s2.getAge();
  5.         int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
  6.         return num2;
  7.     }
  8. });

13.模拟斗地主

需求：通过程序实现斗地主过程中的洗牌，发牌和看牌

  1. package com.study_02;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  6. public class PokerDemo {
  7.     public static void main(String[] args) {
  8.         // 创建牌盒
  9.         ArrayList<String> array = new ArrayList<>();
  11.         // 网牌盒里面装牌
  14.         // 定义花色数组
  15.         String[] colors = {"♦", "♣", "♠", "♥"};
  16.         // 定义点数数组
  17.         String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
  18.         for (String color : colors) {
  19.             for (String number : numbers) {
  20.                 array.add(color + number);
  21.             }
  22.         }
  23.         array.add("大王");
  24.         array.add("小王");
  26.         // 洗牌
  27.         Collections.shuffle(array);
  29.         // 发牌
  30.         ArrayList<String> lqxArray = new ArrayList<>();
  31.         ArrayList<String> lyArray = new ArrayList<>();
  32.         ArrayList<String> fqyArray = new ArrayList<>();
  33.         ArrayList<String> dpArray = new ArrayList<>(); // 底牌三张
  35.         for (int i = 0; i < array.size(); i++) {
  36.             String poker = array.get(i);
  37.             if (i >= array.size() - 3) {
  38.                 dpArray.add(poker);
  39.             } else if (i % 3 == 0) {
  40.                 lqxArray.add(poker);
  41.             }else if (i % 3 == 1) {
  42.                 lyArray.add(poker);
  43.             }else if (i % 3 == 2) {
  44.                 fqyArray.add(poker);
  45.             }
  46.         }
  47.         lookPooker("林青霞",lqxArray);
  48.         lookPooker("柳岩",lyArray);
  49.         lookPooker("风情杨",fqyArray);
  50.         lookPooker("底牌",dpArray);
  51.     }
  53.     // 看牌的方法
  54.     public static void lookPooker(String name,ArrayList<String> array) {
  55.         System.out.println(name + "的牌是:");
  56.         for (String poker : array) {
  57.             System.out.print(poker+" ");
  58.         }
  59.         System.out.println();
  60.     }
  61. }

14.案例：模拟斗地主升级版

需求：通过程序实现斗地主过程中的洗牌，发牌和看牌。要求：对牌进行排序

  1. package com.study_03;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.HashMap;
  6. import java.util.TreeSet;
  8. public class PokerDemo {
  9.     public static void main(String[] args) {
  10.         // 创建hashmap集合,键是编号,值是牌
  11.         HashMap<Integer, String> hm = new HashMap<>();
  13.         // 存储编号
  14.         ArrayList<Integer> array = new ArrayList<>();
  16.         // 创建花色数组和点数组
  18.         // 定义花色数组
  19.         String[] colors = {"♦", "♣", "♠", "♥"};
  20.         // 定义点数数组
  21.         String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
  23.         int index = 0;
  24.         for (String number : numbers) {
  25.             for (String color : colors) {
  26.                 hm.put(index, color + number);
  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);
  37.         // 洗牌(洗的是编号),用Collection的shuffle()方法实现
  38.         Collections.shuffle(array);
  40.         // 发牌
  41.         TreeSet<Integer> lqxSet = new TreeSet<>();
  42.         TreeSet<Integer> lyxSet = new TreeSet<>();
  43.         TreeSet<Integer> fqySet = new TreeSet<>();
  44.         TreeSet<Integer> dpSet = new TreeSet<>();
  46.         for (int i = 0; i < array.size(); i++) {
  47.             int x = array.get(i);
  48.             if (i >= array.size() - 3) {
  49.                 dpSet.add(x);
  50.             } else if (i % 3 == 0) {
  51.                 lqxSet.add(x);
  52.             }else if (i % 3 == 1) {
  53.                 lyxSet.add(x);
  54.             }else if (i % 3 == 2) {
  55.                 fqySet.add(x);
  56.             }
  57.         }
  59.         lookPoker("林青霞",lqxSet,hm);
  60.         lookPoker("柳岩",lyxSet,hm);
  61.         lookPoker("风情杨",fqySet,hm);
  62.         lookPoker("底牌",dpSet,hm);
  63.     }
  65.     // 定义方法看牌
  66.     public static void lookPoker(String name, TreeSet<Integer> ts,HashMap<Integer,String> hm) {
  67.         System.out.println(name + "的牌是:");
  68.         for (Integer key : ts) {
  69.             String poker = hm.get(key);
  70.             System.out.print(poker+" ");
  71.         }
  72.         System.out.println();
  73.     }
  74. }