排序容器——高淇JAVA300讲笔记之TreeSet与TreeMap

• TreeMap:确保key可以排序或者提供比较器
  • 确保key可以排序
  • 提供key比较器　　

                 public TreeMap(Comparator<?super K> comparator)

• TreeSet:
  • 确保元素实体可以排序
  • 排序比较器　　

                 public TreeSet(Comparator<?super E> comparator)

1.TreeSet：数据元素可以排序且不可重复

对比：Set接口：HashSet，元素必须重写hashCode和equals方法。

去重：比较等于0即重复。

1）、元素可以排序 java.lang.Comparable接口 + compareTo方法

new TreeSet()

2）、排序业务类 java.util.Comparator接口 + compare方法

new TreeSet(Comparator<? super E> comparator)

注意：在添加数据时排序，数据更改不会影响原来的顺序。所以不要修改数据，否则可能重复

下面来看例子。

TreeSet案例一：实现java.util.Comparator接口

先建一个Person类，里面包含姓名、帅气指数。

package com.bjsxt.sort.col;

public class Person {
    private final String name;//名称，这里加上final，是为了保证值不能被修改，以免在set里发生值重复的情况
    private final int handsome;//帅气指数
    
    //无参构造器
    public Person() {
        super();
        name = null;
        handsome = 0;
    }

    //有参构造器
    public Person(String name, int handsome) {
        super();
        this.name = name;
        this.handsome = handsome;
    }

    public String getName() {
        return name;
    }

    public int getHandsome() {
        return handsome;
    }

    @Override
    public String toString() {
        return "姓名："+this.name+"，帅气指数"+this.handsome+"
";
    }
    
    
}

然后利用业务排序类进行排序。注意，对象是在存放到TreeSet容器内的过程中进行排序的，且数据更改不会影响原来的顺序。所以不要修改数据，否则可能重复。

package com.bjsxt.sort.col;

import java.util.TreeSet;

/**
 * 提供了解耦的方式：业务排序类
 *
 */
public class TreeSetDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person p1 = new Person("您",100);
        Person p2 = new Person("刘德华",1000);
        Person p3 = new Person("梁朝伟",1200);
        Person p4 = new Person("老裴",50);
        
        //依次存放到Tree容器中，使用排序的业务类（匿名内部类）
        TreeSet<Person> persons = new TreeSet<Person>(
                    new java.util.Comparator<Person>() {

                        @Override
                        public int compare(Person o1, Person o2) {
                            return o1.getHandsome() - o2.getHandsome();
                        }
                        
                    }
                );
        persons.add(p1);
        //TreeSet 在添加数据时排序
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);
        
        System.out.println(persons);
        /*
        //改变数据
        p4.setHandsome(100);
        p4.setName("您");
        */
        //p4与p1内容重复
         
        //System.out.println(persons);
        
    }

}

运行结果：按帅气值升序。

[姓名：老裴，帅气指数50
, 姓名：您，帅气指数100
, 姓名：刘德华，帅气指数1000
, 姓名：梁朝伟，帅气指数1200
]

TreeSet案例二：实现 java.lang.Comparable接口

先建一个工人类Worker，这个实体类实现了java.lang.Comparable接口，并且重写了compareTo方法，按工资升序。

package com.bjsxt.sort.col;

public class Worker implements java.lang.Comparable<Worker>{
    //工种
    private String type;
    //工资
    private double salary;
    
    //无参构造器
    public Worker() {
        super();
    }
    
    //带参构造器
    public Worker(String type, double salary) {
        super();
        this.type = type;
        this.salary = salary;
    }

    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }

    /**
     * 按工资升序
     */
    @Override
    public int compareTo(Worker o) {
        return this.salary>o.salary?1:(this.salary==o.salary?0:-1);
    }
    
    @Override
    public String toString() {
        return "工种：" + this.type + "，工资：" + this.salary + "
";
    }
    
}

然后将对象存入TreeSet，在存入时进行排序。

package com.bjsxt.sort.col;

import java.util.TreeSet;

/**
 * 实体类实现Comparable 接口的应用
 *
 */
public class TreeSetDemo02 {
    public static void main(String[] args) {
        Worker w1 = new Worker("垃圾回收员",12000);
        Worker w2 = new Worker("农名工",8000);
        Worker w3 = new Worker("程序猿",5000);
    
        TreeSet<Worker> employees = new TreeSet<Worker>();
        employees.add(w1);
        employees.add(w2);
        employees.add(w3);
        System.out.println(employees);
    }
}

运行结果：按工资升序。

[工种：程序猿，工资：5000.0
, 工种：农名工，工资：8000.0
, 工种：垃圾回收员，工资：12000.0
]

2.TreeMap：要求键可以排序，与上述TreeSet同理

TreeMap案例1：实现 java.util.Comparator接口

Person类同上，这里就不重复贴了。

下面是排序代码。

package com.bjsxt.sort.col;

import java.util.Set;
import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
        Person p1 = new Person("您",100);
        Person p2 = new Person("刘德华",1000);
        Person p3 = new Person("梁朝伟",1200);
        Person p4 = new Person("老裴",50);
        
        TreeMap<Person,String> map = new TreeMap<Person,String>(
                    new java.util.Comparator<Person>() {
    
                        @Override
                        public int compare(Person o1, Person o2) {
                            return o1.getHandsome() - o2.getHandsome();
                        }
                        
                    }
                );
        map.put(p1, "bjsxt");
        map.put(p2, "bjsxt");
        map.put(p3, "bjsxt");
        map.put(p4, "bjsxt");
        
        //查看键
        Set<Person> persons = map.keySet();
        System.out.println(persons);
        
    }
}

运行结果：按照帅气值升序。

[姓名：老裴，帅气指数50
, 姓名：您，帅气指数100
, 姓名：刘德华，帅气指数1000
, 姓名：梁朝伟，帅气指数1200
]

TreeMap案例2：实现了java.lang.Comparable接口

Worker类同上，这里就不重复贴了。

下面是排序代码。

package com.bjsxt.sort.col;

import java.util.TreeMap;

public class TreeMapDemo02 {
    public static void main(String[] args) {
        Worker w1 = new Worker("垃圾回收员",12000);
        Worker w2 = new Worker("农名工",8000);
        Worker w3 = new Worker("程序猿",5000);
    
        TreeMap<Worker,String> employees = new TreeMap<Worker,String>();
        employees.put(w1,"bjsxt");
        employees.put(w2,"bjsxt");
        employees.put(w3,"bjsxt");
        System.out.println(employees.keySet());
    }
}

运行结果：

[工种：程序猿，工资：5000.0
, 工种：农名工，工资：8000.0
, 工种：垃圾回收员，工资：12000.0
]