关于TreeMap和TreeSet的实例研究和总结

古城微笑少年丶 2022-05-21 05:41 281阅读 0赞

# 　ＴｒｅｅＳｅｔ实例 #

1.  往TreeSet添加元素的时候，如果元素本身具备了自然顺序的特性（数字按照值得大小，字符串按照顺序字符的ＡＳＣＩＩ码排序），那么就按照元素自然顺序的特性进行排序存储。
2.  往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，那么该元素所属的类必须要实现Comparable接口，把元素  
    的比较规则定义在compareTo()方法上。
3.  如果比较元素的时候，compareTo方法返回的是0，那么该元素就被视为重复元素，不允许添加.  
    (注意：TreeSet与HashCode、equals方法是没有任何关系。)
4.  往TreeSet添加元素的时候, 如果元素本身没有具备自然顺序 的特性，而元素所属的类也没有实现Comparable接口，  
    那么必须要在创建TreeSet的时候传入一个比较器。
5.  往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，而元素所属的类已经实现了Comparable接口，  
    在创建TreeSet对象的时候也传入了比较器那么是以 比较器的比较规则优先 使用。

如何自定义定义比较器： 自定义一个类实现Comparator接口即可，把元素与元素之间的比较规则定义在compare方法内即可。

package com.dlut.jeremy;
    
    import java.util.Comparator;
    import java.util.Iterator;
    import java.util.TreeSet;
    
    public class Main {
        
        public static void main(String[] args) {
            // 当TreeSet加入具有自然排序特性的元素时
            TreeSet ts = new TreeSet();
            ts.add(1);
            ts.add(3);
            ts.add(2);
            System.out.println(ts.toString());
            // 当TreeSet加入具有自然排序特性的元素时（字符串也是可以排序的哦）
            TreeSet<String> treeSetStr = new TreeSet<String>();
            treeSetStr.add("2");
            treeSetStr.add("1");
            treeSetStr.add("a");
            treeSetStr.add("a"); // 编译和运行都不会报错
            System.out.println(treeSetStr.toString());
            // 
            // 用Comparable接口，此时比较salary
            TreeSet tree = new TreeSet();
            tree.add(new Employee("Jay", 1, 1000));
            tree.add(new Employee("Lee", 4, 3000));
            tree.add(new Employee("MJ", 2, 2000));
            tree.add(new Employee("JK", 3, 500));
    
            System.out.println("用Comparable接口，此时比较salary");
            Iterator it = tree.iterator();
            while (it.hasNext()) {
                System.out.println(it.next());
            }
    
            System.out.println("*******************");
    
            // 用Comparator比较器,此时比较id
            MyComparator comparator = new MyComparator();// 创建一个比较器对象
            TreeSet tree2 = new TreeSet(comparator); // 创建TreeSet的时候传入比较器
            tree2.add(new Employee("Jay", 1, 1000));
            tree2.add(new Employee("Lee", 4, 3000));
            tree2.add(new Employee("MJ", 2, 2000));
            tree2.add(new Employee("JK", 3, 500));
    
            System.out.println("用Comparator比较器,此时比较id");
            Iterator it2 = tree2.iterator();
            while (it2.hasNext()) {
                System.out.println(it2.next());
            }
    
        }
    }
    
    class Employee implements Comparable<Employee> {
        
        String name;
        int id;
        int salary;
    
        public Employee(String name, int id, int salary) {
            this.name = name;
            this.id = id;
            this.salary = salary;
        }
    
        @Override
        public String toString() {
            return "{name=" + name + ", id=" + id + ", salary=" + salary + "}";
        }
    
        @Override
        public int compareTo(Employee e) { // 负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。
            return this.salary - e.salary;
        }
    }
    
    // 自定义一个比较器
    class MyComparator implements Comparator<Employee> {
        
        @Override
        public int compare(Employee o1, Employee o2) {
            return o1.id - o2.id;
        }
    }

**程序运行结果：**

[1, 2, 3]
    [1, 2, a]
    用Comparable接口，此时比较salary
    {
       name=JK, id=3, salary=500}
    {
       name=Jay, id=1, salary=1000}
    {
       name=MJ, id=2, salary=2000}
    {
       name=Lee, id=4, salary=3000}
    *******************
    用Comparator比较器,此时比较id
    {
       name=Jay, id=1, salary=1000}
    {
       name=MJ, id=2, salary=2000}
    {
       name=JK, id=3, salary=500}
    {
       name=Lee, id=4, salary=3000}

# ＴｒｅｅＭａｐ的实例 #

**基本原则和上面的TreeSet一样，但是推荐使用在构建TreeMap的时候，尽量传入一个comparator来进行对map的排序，比如下例**

package com.dlut.jeremy;
    import java.util.Comparator;
    import java.util.TreeSet;
    //person实体类
    class Person {
      private String name;
      private int handsome;
    
      public Person() {
          // TODO Auto-generated constructor stub
      }
    
      public Person(String name, int handsome) {
          super();
          this.name = name;
          this.handsome = handsome;
      }
    
      public String getName() {
          return name;
      }
    
      public void setName(String name) {
          this.name = name;
      }
    
      public int getHandsome() {
          return handsome;
      }
    
      public void setHandsome(int handsome) {
          this.handsome = handsome;
      }
    
      @Override
      public String toString() {
          return "Person [name=" + name + ", handsome=" + handsome + "]\n";
      }
    
    }
    
    public class TreeMapTest {
        
      public static void main(String[] args) {
          Person p1=new Person("depp",100);
          Person p2=new Person("tom",90);
          Person p3=new Person("jack",50);
    
          TreeSet<Person> ts=new TreeSet<Person>(new Comparator<Person>(){
    
              public int compare(Person o1, Person o2) {
    
                  return o1.getHandsome()-o2.getHandsome();//升序
              }
    
          });
    
          //TreeSet在添加数据时排序,而Collections的sort方法是在元素添加完成以后排序
          ts.add(p1);
          ts.add(p2);
          ts.add(p3);
    
          System.out.println(ts);
    
          //改变数据，排序不会改变
          p3.setHandsome(120);
          System.out.println(ts);
    
      }
    }

**程序运行结果：**

[Person [name=jack, handsome=50]
        , Person [name=tom, handsome=90]
        , Person [name=depp, handsome=100]
        ]
        [Person [name=jack, handsome=120]
        , Person [name=tom, handsome=90]
        , Person [name=depp, handsome=100]
        ]