学习目标
    ●排序查找算法
    ○冒泡排序
    ○选择排序
    ○二分查找
    ●Map集合
    ○Map集合的特点
    ○Map集合的特点及实现类
    ○Map集合的遍历方式
    ●集合嵌套
    ○单列集合嵌套单列集合
    ○单列集合嵌套双列集合
    ○双列集合嵌套双列集合
    ●集合案例-斗地主

    1. Map集合
    1.1 什么时使用双列集合 ?
    1.集合中保存的数据是成对存在的叫做双列集合。
    2.用来表示一一对应的数据。
    2.2 HashMap集合特点及使用 ?
    1.特点：键唯一和无序。
    2.使用跟Map一样但是要注意，自定义类需要重写hashCode和equals方法才能达到去重的作用。
    3.3 双列集合遍历方式及区别 ?
    调用map集合的entrySet方法获取所有的键值对对象→→遍历每一个键值对对象（Entry对象）→→getKey获取键，getValue获取值
    区别就是获取的是一对数据而不是一个数据。
    3.4 集合的体系及每一种集合的特点 ?

    集合的体系 特点（1） 特点（2） 特点（3）
    Map 键不能重复值可以重复 数据都是一一对应的 （键 + 值） 一起是一个整体
    HashMap 底层是数组加列表：查询快 可以重写hashCode和equals方法达到去重效果 可以通过重写方法以hash值排序
    LinkedHashMap 元素唯一 元素有序
    TreeMap 能去重 排序


    2. 排序查找算法
    2.1 排序查找算法思想及代码实现 ?
    1.冒泡排序原理：相邻的数据两两比较，小的放前面，大的放后面。

    1. public static void main(String[] args) {
    2.         int[] arr = {9, 1, 6, 8, 7};
    4.         for (int x = 0; x < arr.length-1; x++) {
    5.             for (int i = 0; i < arr.length - 1 - x; i++) {
    6.                 if (arr[i] > arr[i + 1]) {//升序
    7.                     //降序arr[i] < arr[i + 1]
    8.                     int temp = arr[i];
    9.                     arr[i] = arr[i + 1];
    10.                     arr[i + 1] = temp;
    11.                 }
    12.             }
    14.         }
    15.         System.out.println(Arrays.toString(arr));
    16. }

    2.选择排序原理：是每一次从待排序的数据中选出最小的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据排完为止。

    1. public class SortDemo {
    2.     public static void main(String[] args) {
    3.         int[] arr = {55, 11, 44, 22, 33};
    4.         for (int i = 0; i < arr.length; i++) {
    5.             //定义变量记录当前排序中最小元素排列
    6.             int minValueIndex = i;
    7.             //遍历当前元素一直到数组末尾
    8.             for (int j = i + 1; j < arr.length; j++) {
    9.                 if (arr[j] < arr[minValueIndex]) {
    10.                     minValueIndex = j;
    11.                 }
    12.             }
    13.             //元素交换位置
    14.             if (i != minValueIndex){
    15.                 int temp = arr[i];
    16.                 arr[i] = arr[minValueIndex];
    17.                 arr[minValueIndex] = temp;
    18.             }
    20.         }
    21.         System.out.println(Arrays.toString(arr));
    22.     }
    23. }

    3.二分查找的原理是：每次去掉一半的查找范围

    1. public class BinarySearchDemo {
    2.     public static void main(String[] args) {
    3.         int []arr = {1,2,3,4,5,6,7,8,9,10};
    4.         System.out.println(Arrays.binarySearch(arr, 7));
    5.     }
    7.     public static int binarySearch(int[] arr, int num) {
    8.         int min = 0;
    9.         int max = arr.length - 1;
    10.         while (min <= max) {
    11.             int mid = (min = max) / 2;
    12.             if (arr[mid] == num) {
    13.                 return mid;
    14.             } else if (arr[mid] > num) {
    15.                 max = mid - 1;
    17.             } else {
    18.                 min = mid + 1;
    19.             }
    20.         }
    21.         return -1;
    22.     }
    23. }

    3. 当日问题小结
    3.1 当日遇到的问题

    3.2 出现问题原因

    3.3 解决问题方案

    若有收获，就点个赞吧