06-JavaSE进阶-Map集合

1. TreeSet集合
- 1.1 TreeSet集合特点
- 1.2 排序规则
2. Collections单列集合工具类
- 2.1 shuffle 方法
- 2.2 sort 方法
3. 可变参数
4. Map集合
5. 排序查找算法
- 5.1 排序查找算法思想及代码实现 ?
6. 集合嵌套

学习目标

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

1. TreeSet集合

1.1 TreeSet集合特点
元素唯一
无索引
有序

1.2 排序规则

1.2.1 自然排序
使用空参构造创建TreeSet集合对象

存储元素所在的类需要实现Comparable接口

public class Student implements Comparable<Student> {}；

重写Comparable接口中的抽象方法 compareTo方法,指定排序规则

@Override
  public int compareTo(Student o) {
      int result = this.age - o.age;
      return result == 0 ? this.name.compareTo(o.name) : age;
  }

1.2.2 比较器排序

TreeSet的带参构造方法使用的是 “比较器排序” 对元素进行排序的
比较器排序，就是让TreeSet集合构造方法接收Comparator接口的实现类对象
```
TreeSet<Student> ts = new TreeSet<>(new ComparatorImpl());
```

重写Comparator接口中的 compare(T o1,T o2)方法 , 指定排序规则

static class ComparatorImpl implements Comparator<Student> {
//o1代表的是当前往集合中添加的元素 , o2代表的是集合中已经存在的元素
      @Override
      public int compare(Student o1, Student o2) {
          int result = o1.getAge() - o2.getAge();
          return result == 0 ? o1.getName().compareTo(o2.getName()): result;
      }
  }

1.2.3 两种排序的注意点

如果自然排序和比较器排序都存在 , 那么会使用比较器排序

2. Collections单列集合工具类

2.1 shuffle 方法

public static void shuffle(List<?> list) 对集合中的元素进行打乱顺序（只作用于List集合,?任意类型）

Collections.shuffle(list);

2.2 sort 方法

public static void sort (List list): 对集合中的元素自然排序（只作用于List集合）
```
Collections.sort(list);
```

public static void sort (List list, Comparator<? super T> c)（只作用于List集合）

Collections.sort(list, new Comparator<Integer>() {
          @Override
          public int compare(Integer o1, Integer o2) {
              return o2-o1;
          }
      });

3. 可变参数

3.1 可变参数是什么

在 JDK5 中提供了可变参数，允许在调用方法时传入任意个参数。可变参数原理就是一个数组形式存在
格式 : 修饰符返回值类型方法名(数据类型… 变量名) { }
```
public static void sum(int... num) {}
```
3.2 addAll方法
static boolean addAll(Collection<? super T> c , T… elements) : 添加任意多个数据到集合中
```
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 10, 20, 30, 40);
```
3.3 可变参数注意事项
可变参数只能作为方法的最后一个参数，但其前面可以有或没有任何其他参数。

可变参数本质上是数组，不能作为方法的重载。如果同时出现相同类型的数组和可变参数方法，是不能编译通过的。

4. Map集合

4.1 什么时使用双列集合 ?

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

4.2 HashMap集合特点及使用 ?

HashMap具有键唯一，无序的特点

Map<String, String> map = new HashMap<>();
System.out.println(map.put("键","值"));//添加
System.out.println(map.remove("键"));//删除
System.out.println(map.get("键"));//获取
System.out.println(map.containsKey("键"));//判断该集合中是否有此键
Set<String> s = map.keySet();//获取Map集合中所有的键，存储到Set集合中

4.3 双列集合遍历方式及区别 ?

4.3.1 键找值遍历

Set<String> set = map.keySet();//获取键集合
//遍历键集合
for (String s : set) {
 String value = map.get(s);}//通过键找到值

4.3.2 获取键值对对象，再找键和值

//获取键值对对象集合，set键值对集合
Set<Map.Entry<String, String>> set = map.entrySet();
//遍历键值对对象，获得每一个键值对
for (Map.Entry<String, String> entry : set) {
 String key = entry.getKey();
 String value = entry.getValue();}

4.4 集合的体系及每一种集合的特点 ?

| HashMap集合 | LinkedHashMap集合 | TreeMap集合 | | —- | —- | —- | —- | | 特点 | 键唯一 | 元素唯一 | 键唯一 | | | 无序 | 有序 | 自然排序，比较器排序 | | 数据结构 | 哈希表结构 | 链表和哈希表结构 | 红黑树 |

5. 排序查找算法

5.1 排序查找算法思想及代码实现 ?

5.1.1 冒泡排序

相邻元素两两作比较 , 大的元素往后放

public class SortDemo {
    public static void main(String[] args) {
        int[] arr = {3, 5, 2, 1, 4};
        //比较轮次
        for (int i = 0; i < arr.length - 1; i++) {
            //每个轮次进行比较次数
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    int temp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

5.1.2 选择排序

每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾

public class SortDemo {
    public static void main(String[] args) {
        int[] arr={55, 11, 44, 22, 33};
        for (int i = 0; i < arr.length-1; i++) {
            int minIndex=i;
            for (int j = i+1; j < arr.length; j++) {
                if(arr[j]<arr[minIndex]){
                    minIndex=j;
                }
            }
            if (i !=minIndex){
                int temp=arr[i];
                arr[i]=arr[minIndex];
                arr[minIndex]=temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

5.1.3 二分查找

每次去掉一半的查找范围

public class BinarySearchDemo {
    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println(binarySearch(arr,7));
    }
    public static int binarySearch(int[] arr,int num){
        int min =0;
        int max =arr.length-1;
        while (min<=max){
            int mid=(min+max)/2;
            if(arr[mid]==num){
                return mid;
            }
            else if (arr[mid]<num){
                min=mid-1;
            }
            else if (arr[mid]>num){
                max=mid-1;
            }
        }
        return -1;
    }
}

6. 集合嵌套

6.1 List嵌套List

        List<String> class1 = new ArrayList<>();
        List<String> class2 = new ArrayList<>();
        List<String> class3 = new ArrayList<>();
        List<List<String>> grade = new ArrayList<>();
        //遍历年级，获取班级的集合
        for (List<String> c : grade) {
            //遍历每个班级，获取每个学生
            for (String name : c) {
                System.out.println(name);
            }
        }

6.2 List嵌套Map

        Map<String,String> class1=new HashMap<>();
        Map<String,String> class2=new HashMap<>();
        Map<String,String> class3=new HashMap<>();
        List<Map<String,String>> grade=new ArrayList<>();
        //遍历年级，得到班级集合
        for (Map<String, String> c : grade) {
            //获取班级集合所有的键，存储到set集合中
            Set<String> set = c.keySet();
            //遍历键集合，得到键
            for (String s : set) {
                String name = c.get(s);//由键获取值
                System.out.println(name);
            }
        }

6.3 Map嵌套Map

        Map<String,String> class1=new HashMap<>();
        Map<String,String> class2=new HashMap<>();
        Map<String,String> class3=new HashMap<>();
        Map<String,Map<String,String>> grade=new HashMap<>();
        //获取班级集合
        Set<String> class集合 = grade.keySet();
        //遍历班级集合，得到每个班级
        for (String 班级 : class集合) {
            Map<String, String> 每个班级所有人 = grade.get(班级);
            Set<String> 学生的学号 = 每个班级所有人.keySet();
            //遍历学生学号，获取每个学生的学号
            for (String 学号 : 学生的学号) {
                String 学生姓名 = 每个班级所有人.get(学号);
                System.out.println("班级名字"+班级+"，学号"+学号+",姓名"+学生姓名);
            }

1. TreeSet集合

1.1 TreeSet集合特点

1.2 排序规则

1.2.1 自然排序