阶段二26_面向对象高级_集合8-[TreeMap,可变参数，创建不可变集合]

知识：

 (1)TreeMap：
    底层数据是红黑树，节点是Entry对象(健值对象)
    TreeMap使用自然排序或者比较器排序案例
 (2)可变参数
 (3)创建不可变集合

一.TreeMap

TreeMap底层是红黑树结构的
依赖自然排序或者比较器排序，对键进行排序
如果键存储的是自定义对象，需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
遍历：-->>先获取左边-->>再获取中间-->>再获取右边

二.TreeMap练习

(1)需求：

创建一个TreeMap集合，键是学生对象(Student)，值是籍贯(String)。
学生属性姓名和年龄，按照年龄进行排序并遍历

(2)代码实现：

public class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student() { }
    public Student(String name, int age) { this.name = name;this.age = age;}
    public String getName() { return name;}
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age;}
    @Override
    public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age +'}';}

    /**1.实现Comparable接口，来实现自然排序*/
    @Override
    public int compareTo(Student o) {
        //按照年龄进行排序
        int result = o.getAge() - this.getAge();
        //次要条件，按照姓名排序。
        result = result == 0 ? o.getName().compareTo(this.getName()) : result;
        return result;
    }
  }
  
  public class Test1 {
    public static void main(String[] args) {
        TreeMap<Student,String> tm = new TreeMap<>(
            /**2.创建TreeMap对象的时候，传入Comparator比较器进行排序*/
			new Comparator<Student>() {
				@Override
				public int compare(Student o1, Student o2) {
					int result = o1.getAge() - o2.getAge();
					result = result== 0 ? o1.getName().compareTo(o2.getName()) : result;
					return result;
				}
			}
        );
        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("dapang",22);
        Student s3 = new Student("xiaomei",22);
        tm.put(s1,"江苏");
        tm.put(s2,"北京");
        tm.put(s3,"天津");
        tm.forEach(
           (Student key, String value)->{  System.out.println(key + "---" + value); }
        );
    }
  }

三.可变参数

(1)可变参数概念：

可变参数：就是形参的个数是可以变化的
格式：修饰符 返回值类型 方法名(数据类型… 变量名) {  }
范例：public static int sum(int… a) {  }

(2)可变参数注意事项:

这里的变量其实是一个数组
如果一个方法有多个参数，包含可变参数，可变参数要放在最后

(3)可变参数案例：

  public class MyVariableParameter3 {
    public static void main(String[] args) {
        int sum1 = getSum(1, 2, 3, 4, 5);
        System.out.println(sum1);
    }
    public static int getSum(int number,int... arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {   sum = sum + arr[i];  }
        return sum;
    }
  }

四.创建不可变集合

(1)创建不可变集合使用的静态方法：

 static <E>  List<E>  of(E…elements)  创建一个具有指定元素的List集合对象
 static <E>  Set<E>  of(E…elements)    创建一个具有指定元素的Set集合对象
 static <K , V>   Map<K，V>  of(E…elements)  创建一个具有指定元素的Map集合对象

(2)创建不可变集合具体案例实现：

public class MyVariableParameter4 {
    public static void main(String[] args) {
        //1.static   List  of(E…elements)  创建一个具有指定元素的List集合对象
          List<String> list = List.of("a", "b", "c", "d");
          System.out.println(list);
          //集合的批量添加。
          //首先是通过调用List.of方法来创建一个不可变的集合，of方法的形参就是一个可变参数。
          //再创建一个ArrayList集合，并把这个不可变的集合中所有的数据，都添加到ArrayList中。
          ArrayList<String> list3 = new ArrayList<>(List.of("a", "b", "c", "d"));
          System.out.println(list3);
       
       
       //2.static   Set  of(E…elements)    创建一个具有指定元素的Set集合对象
         //传递的参数当中，不能存在重复的元素。
         Set<String> set = Set.of("a", "b", "c", "d","a");
         System.out.println(set);
         
       //3.static    Map  of(E…elements) 创建一个具有指定元素的Map集合对象
        Map<String, String> map1 = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");
        System.out.println(map1);
        Map<String, String> map2 = Map.ofEntries(Map.entry("zhangsan", "江苏"), Map.entry("lisi", "北京"));
        System.out.println(map2);
    }
  }

(3)小结：

在List、Set、Map接口中，都存在of方法，可以创建一个不可变的集合。
这个集合不能添加，不能删除，不能修改。
可以结合集合的带参构造，实现集合的批量添加(就不需要调用多个add put方法)。
在Map接口中，还有一个ofEntries方法可以提高代码的阅读性。
首先会把键值对封装成一个Entry对象，再把这个Entry对象添加到集合当中。

五.更多内容
http://www.gxcode.top/code