1.TreeMap类

• 概述：键是红黑树结构，可以保证键的排序和唯一性

遍历集合；

package com.bigdat.java.day22;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/*
            TreeMap类概述
                键是红黑树结构，可以保证键的排序和唯一性
 */
public class TreeMapDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        TreeMap treeMap = new TreeMap();
        //向集合中添加元素
        treeMap.put(1001, "张三");
        treeMap.put(1002, "李四");
        treeMap.put(1003, "王五");
        treeMap.put(1001, "二狗子"); //结果会对张三的结果产生压盖，就只会产生二狗子
        treeMap.put(1004, "王二麻子");
        //遍历集合
        Set integers = treeMap.keySet();
        for (Integer integer : integers) {
            String s = treeMap.get(integer);
            System.out.println("编号："+integer+",姓名："+s);
        }
        System.out.println("===============================================");
        Set> entries = treeMap.entrySet();
        Iterator> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry next = iterator.next();
            Integer key = next.getKey();
            String value = next.getValue();
            System.out.println("编号："+key+",姓名："+value);
        }
    }
}

HashMap

注意事项；排序分为自然排序

• 自然排序：引用类型必须实现Comparable接口（因为源码中compar有一个向下转型的步骤），然后重写compareTo()方法；
  根据需求先比较什么什么就是主要条件因为红黑树采用中序遍历^,如下

    @Override
    public int compareTo(Student4 o) {
        int i = this.name.compareTo(o.name);
        //姓名一样，年龄不一定一样
        int i2 = (i == 0) ? this.age - o.age : i;
        return i2;
    }

• 比较器排序：调用的是引用类型中的有参构造器
  //TreeMap tMap = new TreeMap<>();
  ，引用类中必须实现Comparator接口。然后重写compare()方法或直接在main（）方法中实现匿名内部类操作

public class TreeMapDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        //TreeMap tMap = new TreeMap<>();
        //比较器排序
        //TreeMap tMap = new TreeMap(new Student4());
        //匿名内部类实现比较器排序
        TreeMap tMap = new TreeMap(new Comparator(){

            @Override
            public int compare(Student4 o1, Student4 o2) {
                return 0;
            }
        });

代码如下：

import java.util.*;

/*
        HashMap
 */
public class TreeMapDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        //TreeMap tMap = new TreeMap<>();
        //比较器排序
        //TreeMap tMap = new TreeMap(new Student4());
        //匿名内部类实现比较器排序
        TreeMap tMap = new TreeMap(new Comparator(){

            @Override
            public int compare(Student4 o1, Student4 o2) {
                return 0;
            }
        });
        //创建学生类对象
        Student4 s1 = new Student4("白骨精",10);
        Student4 s2 = new Student4("观世音菩萨",32);
        Student4 s3 = new Student4("铁扇公主",27);
        Student4 s4 = new Student4("白骨精",10);
        Student4 s5 = new Student4("太上老君",55);
        Student4 s6 = new Student4("比较的太上老君",55);

        //向集合中添加元素
        tMap.put(s1,1001);
        tMap.put(s2,1002);
        tMap.put(s3,1003);
        tMap.put(s4,1004);
        tMap.put(s5,1005);
        tMap.put(s6,1006);

        //遍历集合
        Set> entries = tMap.entrySet();
        Iterator> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry next = iterator.next();
            Student4 key = next.getKey();
            Integer value = next.getValue();
            System.out.println("学生:"+key+",编号："+value);
        }

    }
}

引用类型（Stuedent）代码如下：

package com.bigdat.java.day22;
import java.util.Comparator;

/*
    创建学生对象
 */
public class Student4 implements Comparator {
    private String name;
    private int age;

    public Student4() {
    }

    public Student4(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 "Student4{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    /*
    如果走自然排序方法的话：引用类型实现Comparable() 方法
    然后重写compareTo 方法
        @Override
    public int compareTo(Student4 o) {
        int i = this.name.compareTo(o.name);
        //姓名一样，年龄不一定一样
        int i2 = (i == 0) ? this.age - o.age : i;
        return i2;
    }
     */
    //比较器排序，创建集合时需要传参，然后引用类型必须实现 Comparator 方法
    //然后再重写 compare 方法
    @Override
    public int compare(Student4 o1, Student4 o2) {
        int i = o1.age - o2.getAge();
        return i;
    }

}

TreeMap 遍历方法如下：

package com.bigdat.java.day22;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/*
            TreeMap类概述
                键是红黑树结构，可以保证键的排序和唯一性
 */
public class TreeMapDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        TreeMap treeMap = new TreeMap();
        //向集合中添加元素
        treeMap.put(1001, "张三");
        treeMap.put(1002, "李四");
        treeMap.put(1003, "王五");
        treeMap.put(1001, "二狗子"); //结果会对张三的结果产生压盖，就只会产生二狗子
        treeMap.put(1004, "王二麻子");
        //遍历集合
        Set integers = treeMap.keySet();
        for (Integer integer : integers) {
            String s = treeMap.get(integer);
            System.out.println("编号："+integer+",姓名："+s);
        }
        System.out.println("===============================================");
        Set> entries = treeMap.entrySet();
        Iterator> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry next = iterator.next();
            Integer key = next.getKey();
            String value = next.getValue();
            System.out.println("编号："+key+",姓名："+value);
        }
    }
}