今日学习目标

  • TreeSet集合(重点)
  • 排序算法
  • 查找算法
  • 可变参数
  • Map集合(重点)
  • 集合嵌套

  • 斗地主案例

    1 TreeSet集合

    属于Set接口的单列集合!

    1.1 TreeSet特点:

  • 元素唯一

  • 无索引

  • 可以按照指定的规则排序(泛型为类时需要类来完成排序方法)

    1.2排序规则

  • 自然排序

    • 存储元素所在的类需要实现Comparable并且重写compareto方法,指定排序规则

  • 比较器排序

    • 就是让TreeSet集合构造方法接收Comparator接口的实现类对象
    • 重写Comparator接口中的 compare(T o1,T o2)方法 , 指定排序规则
    • 排序原理与自然排序相同!

      1.3两种排序规则的区别

  • 自然排序：自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序.

  • 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compareto方法,根据返回值进行排序.
  • 两种方式中，关于返回值的规则：
    • 如果返回值为负数，表示当前存入的元素是较小值，存左边
    • 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
    • 如果返回值为正数，表示当前存入的元素是较大值，存右边

  • 如果两种方式都存在,那么会执行比较器排序

    2 Collections集合工具类

    2.1 shuffle方法

  • 格式: public static void shuffle(List<?> list) 对集合中的元素进行打乱顺序

    • 乱序只能对List集合进行乱序
    • 集合中元素类型可以任意类型

      2.2 sort方法

  • 格式1:public static void sort (List list): 对集合中的元素自然排序

    • 此方法只能对list集合进行排序
    • 从方法中泛型分析可知，集合中元素类型必须是Comparable的子类型
  • 格式2:public static void sort (List list, Comparator<? super T> c)
    • 需要定义比较器Comparator
    • 对元素的类型没有要求
    • 只能对list集合排序

  • sort方法是一个重载的方法，可以实现自然排序及比较器排序。

    3 可变参数

    3.1可变参数的格式和注意事项

  • 格式 : 修饰符 返回值类型 方法名(数据类型… 变量名) { }

  • public void show(int … num) : 表达式该方法可以接收任意个整数值 , 原理 : 其实就是一个int类型的数组
  • 可变参数传参是只能作为最后一个参数
  • 可变参数本质上是数组,不能作为方法的重载使用

  • 如果出现相同类型的数组和可变参数方法,会报错

    3.2可变参数的

  • 调用可变参数方法，可以给出零到任意多个参数

  • 方法中把可变参数当做一个数组去使用即可

    3.3 addAll方法

  • 格式:static boolean addAll(Collection<? super T> c , T… num) : 添加任意多个数据到集合中

  • 该方法就是一个含有可变参数的方法，使用时可以传入任意多个实参，实用方便！

    • Collection<? super T>, 当确定?的类型,就可以往集合里添加此类型和其子类型

      4 排序,查找算法

      4.1 冒泡排序

    • 将一组数据按照从小到大的顺序进行排序(改变符号也可以大到小)

    • 冒泡排序原理 : 相邻元素两两作比较 , 大的元素往后放
      1. for (int j = 0; j < arr.length - 1; j++) {      
      2.        for (int i = 0; i < arr.length - 1 - j; i++) {
      3.            if (arr[i] > arr[i + 1]) {
      4.                int temp = arr[i];
      5.                arr[i] = arr[i + 1];
      6.                arr[i + 1] = temp;
      7.            }
      8.        }
      9.        System.out.println("第" + (j + 1) + "轮排序:" + Arrays.toString(arr));
      10.    }
      11. }
      12. }

      4.2 选择排序

  • 选择排序原理 :和遍历求数组最小值一样,用上循环嵌套可以将全部待排序的数据元素排完。

  • 注意事项 :

    • 如果有n个元素,那么就要比较n-1次

    • 每一趟中都会选出一个最值元素，较前一趟少比较一次

      1. public class SortDemo {
      2. public static void main(String[] args) {
      3.    int[] arr = {4, 1, 5, 3, 2};
      4.    for (int i = 0; i < arr.length - 1; i++) {
      5.        int minIndex = i;
      7.        int min = arr[i];
      8.        for (int j = i; j < arr.length; j++) {
      9.            if (arr[j] < min) {
      10.                minIndex = j; 
      11.                min = arr[j];
      12.            }
      13.        }
      15.        if (i != minIndex) {
      16.            int temp = arr[i];
      17.            arr[i] = arr[minIndex];
      18.            arr[minIndex] = temp;
      19.        }
      20.    }
      22.    System.out.println(Arrays.toString(arr));
      23. }
      24. }

      4.3 二分查找

  • 原理 : 每次去掉一般的查找范围

  • 前提 : 数组必须有序

    5 Map集合

    5.1 Map集合,特点

  • map集合为双列集合

  • 特点 :
    • 键不能重复，值可以重复
    • 键和值是 一 一 对应的，通过键可以找到对应的值
    • （键 + 值） 一起是一个整体 我们称之为“键值对” 或者 “键值对对象”，在Java中叫做“Entry对象”

  • 使用场景:

    • 凡是要表示一一对应的数据时就可以Map集合

      5.2 常用实现类

  • HashMap: 此前HashSet底层就是由HashMap完成的,HashSet保存的元素就是HashMap集合中保存的键,底层结构是哈希码表,具有唯一,无序的特点

    • 注意 : HashMap集合要保证键唯一, 那么键所在的类必须重写hashCode和equals方法
  • LinkedHashMap：底层结构是由链表和哈希表结构组成,元素唯一,有序
  • TreeMap: 底层是红黑树,键去重
    • 若自定义类没有自然排序功能，或自然排序功能不满足要求时。可以自定义比较器排序（Comparator）
    • 可以自然排序（键所在的类要实现Comparable）

5.3 常用的方法

  • public V put(K key, V value)
    • 把指定的键和值添加到Map集合中
  • public V remove(Object key)
    • 把指定的键所对应的键值对再集合中删除,返回被删除的元素
  • public V get(Object key)
    • 根据指定的键,再Map集合中获取对应的值
  • public Set keySet()
    • 获取Map集合中所有的键,存储到Set集合中

  • public boolean containKey(Object key)

    • 判断该集合中是否有此键

      5.4 Map集合的遍历方式

      第一种方式 : 键找值遍历 需要先获取Set集合存储键

      1. // 获取健集合
      2. Set<String> set = hm.keySet();
      4. // 遍历健集合 , 通过键找值
      5. for (String key : set) {
      6.    String value = hm.get(key);
      7.    System.out.println(key + "---" + value);
      8. }
      9. }

      第二种方式 : 获取键值对对象 , 在找到键和值 需要获取Entry对象

      1.    // 获取键值对对象集合
      2.    Set<Map.Entry<String, String>> set = hm.entrySet();
      4.    // 遍历键值对对象集合 , 获取每一个键值对对象
      5.    for (Map.Entry<String, String> entry : set) {
      6.        // 通过entry对象获取键
      7.        String key = entry.getKey();
      8.        // 通过entry对象获取值
      9.        String value = entry.getValue();
      10.        System.out.println(key + "--" + value);
      11.    }
      12. }

      6 集合嵌套(看懂代码)

      6.1 List嵌套List

      1. public static void main(String[] args) {
      2.    List<String> 三年一班 = new ArrayList<>();
      3.    三年一班.add("迪丽热巴");
      4.    三年一班.add("古力娜扎");
      5.    三年一班.add("马尔扎哈");
      6.    三年一班.add("欧阳娜娜");
      8.    List<String> 三年二班 = new ArrayList<>();
      9.    三年二班.add("李小璐");
      10.    三年二班.add("白百何");
      11.    三年二班.add("马蓉");
      13.    List<String> 三年三班 = new ArrayList<>();
      14.    三年三班.add("林丹");
      15.    三年三班.add("文章");
      16.    三年三班.add("陈赫");
      18.    List<List<String>> 年级 = new ArrayList<>();
      19.    年级.add(三年一班);
      20.    年级.add(三年二班);
      21.    年级.add(三年三班);
      23.    for (List<String> 班级 : 年级) {
      24.        for (String name : 班级) {
      25.            System.out.println(name);
      26.        }
      27.        System.out.println("-----------------");
      28.    }
      29. }

      6.2 List嵌套Map

      ```java public static void main(String[] args) { Map 三年一班 = new HashMap<>(); 三年一班.put(“it001”, “迪丽热巴”); 三年一班.put(“it002”, “古力娜扎”); 三年一班.put(“it003”, “马尔扎哈”); 三年一班.put(“it004”, “欧阳娜娜”);

  1.     Map<String, String> 三年二班 = new HashMap<>();
  2.     三年二班.put("it001", "李小璐");
  3.     三年二班.put("it002", "白百何");
  4.     三年二班.put("it003", "马蓉");
  6.     Map<String, String> 三年三班 = new HashMap<>();
  7.     三年三班.put("it001", "林丹");
  8.     三年三班.put("it002", "文章");
  9.     三年三班.put("it003", "陈赫");
  12.     List<Map<String, String>> 年级 = new ArrayList<>();
  13.     年级.add(三年一班);
  14.     年级.add(三年二班);
  15.     年级.add(三年三班);
  17.     for (Map<String, String> 班级 : 年级) {
  18.         Set<String> studentId = 班级.keySet();
  19.         for (String id : studentId) {
  20.             String name = 班级.get(id);
  21.             System.out.println(id + "---" + name);
  22.         }
  23.         System.out.println("=================");
  24.     }
  25. }
  1. <a name="LybrQ"></a>
  2. ### 6.3 Map嵌套Map
  3. ```java
  4.  public static void main(String[] args) {
  6.         Map<String, String> 三年一班 = new HashMap<>();
  7.         三年一班.put("it001", "迪丽热巴");
  8.         三年一班.put("it002", "古力娜扎");
  9.         三年一班.put("it003", "马尔扎哈");
  10.         三年一班.put("it004", "欧阳娜娜");
  13.         Map<String, String> 三年二班 = new HashMap<>();
  14.         三年二班.put("it001", "李小璐");
  15.         三年二班.put("it002", "白百何");
  16.         三年二班.put("it003", "马蓉");
  18.         Map<String, String> 三年三班 = new HashMap<>();
  19.         三年三班.put("it001", "林丹");
  20.         三年三班.put("it002", "文章");
  21.         三年三班.put("it003", "陈赫");
  24.         Map<String, Map<String, String>> 年级 = new HashMap<>();
  25.         年级.put("三年一班", 三年一班);
  26.         年级.put("三年二班", 三年二班);
  27.         年级.put("三年三班", 三年三班);
  29.         Set<String> 班级名字集合 = 年级.keySet();
  31.         for (String 班级名字 : 班级名字集合) {
  32.             Map<String, String> 班级信息 = 年级.get(班级名字);
  33.             Set<String> 学生学号 = 班级信息.keySet();
  34.             for (String 学号 : 学生学号) {
  35.                 String 姓名 = 班级信息.get(学号);
  36.                 System.out.println("班级名字:" + 班级名字 + " ,学号:" + 学号 + " , 名字:" + 姓名);
  37.             }
  38.             System.out.println("============");
  39.         }
  41.     }

7. 当日问题小结

7.1 当日遇到的问题

  • Map集合嵌套Map集合需要多看和理解,比较复杂

    7.2 出现问题原因

  • 今日知识点比较多,需要多复习一下

    7.3 解决问题方案

  • 阅读笔记

  • 老师上课时的代码敲上两边