TreeSet和TreeMap的使用(实现Comparable和Comparator接口)

目录

• TreeSet，TreeMap实现Comparator实现排序
• TreeSet，TreeMap实现Comparable实现排序
  

  ---

TreeSet，TreeMap实现Comparator实现排序

>

(1).TreeSet:
数据元素可以排序(且不需要自己排序,只要自己实现相应的接口(Comparable|Comparator)就可以了)
不可重复性
对比: Set接口: HashSet :元素必须重写hashCode()和equals方法
去重: 比较等于0即重复
1) 元素可以排序: java.lang.Comparable + compareTo
2) 排序业务类 java.util.Comparator + compare
new TreeSet(Comparator < ? super E)
注意 : TreeSet在添加数据时排序 : 数据更改不会影响原来的顺序
TreeSet在使用的过程中不要修改数据,否则可能重复
2.TreeMap
要求键可以排序,与上TreeSet同理

这里先给出一个Person实体类，方便下面使用

public class Person {
    private final String name;   //名字
    private final int handsome;  //帅气指数

    public Person() {   //默认的构造函数 : 初始化时 给定一个值 : 之后数据不会更改
        name = null; 
        handsome = 0;
    }

    public Person(String name, int handsome) {
        super();
        this.name = name;
        this.handsome = handsome;
    }
    /* 数据不可更改
    public void setName(String name) {
        this.name = name;
    }
    public void setHandsome(int handsome) {
        this.handsome = handsome;
    }
    */
    public String getName() {
        return name;
    }
    public int getHandsome() {
        return handsome;
    }
    public String toString() {
        return "姓名:" + this.name + " -->帅气指数 : " + this.handsome + "\n";
    }
}

使用Comparator和TreeSet

import java.util.Iterator;
import java.util.TreeSet;

/**
 * java.util.Comparator + TreeSet
 */


public class TreeSetDemo01 {
    public static void main(String[] args) {
        Person p1 = new Person("zx", 100);
        Person p2 = new Person("刘德华", 1000);
        Person p3 = new Person("梁朝伟", 1500);
        Person p4 = new Person("王力宏", 1300);

        // 依此存放到TreeSet()中 
        //TreeSet()中,Person类不能直接转换成Comparable类,元素必须可以排序
        //这里使用排序的业务类(匿名内部类)
        TreeSet<Person> persons = new TreeSet<Person>(
                new java.util.Comparator<Person>() {
                    @Override
                    public int compare(Person o1, Person o2) { //重写compare方法
                        return o1.getHandsome() - o2.getHandsome(); //升序排列
                    }
                }
            );

        persons.add(p1);
        //TreeSet在添加数据时排序
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);


        //访问方式一 : 遍历
        System.out.println("----------使用迭代器遍历--------------");
        for(Iterator it = persons.iterator();it.hasNext(); ) {
            Person p = (Person)it.next();
            System.out.println(p.getName() + " --> " + p.getName());
        }

        //TreeSet使用过程中不改值
        //p3.setHandsome(100);//在这里把数据更改,但是TreeSet容器中的顺序不会改变
        //使用重写toString直接输出
        System.out.println("--------------使用重写类中的toString()方法查看----------");
        System.out.println(persons);
        /*
        //p3.setName("郑鑫"); //TreeSet使用过程中数据尽量不要重复
        System.out.println("--------------修改数据后TreeSet中数据重复---------");
        System.out.println(persons);
        */
    }

}

使用Comparator和TreeMap

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

/**
 * Comparator + TreeMap
 * @author 郑鑫
 *
 */
public class TreeMapDemo01 {
    public static void main(String[] args) {
        Person p1 = new Person("郑鑫", 100);
        Person p2 = new Person("刘德华", 1000);
        Person p3 = new Person("梁朝伟", 1500);
        Person p4 = new Person("王力宏", 1300);

        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);

    }
}

---

TreeSet，TreeMap实现Comparable实现排序

同上面，也先给出一个Worker实体类(业务排序类，实现Comparable接口)

/**
 * 提供了解耦的方式 : 业务排序类
 * @author 郑鑫
 *
 */

public class Worker implements java.lang.Comparable<Worker> {
    private String type; //工种
    private double salary;

    public Worker() {}

    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.getSalary() > o.getSalary() ? 1 :(this.getSalary() == o.getSalary() ? 0 : -1);
    }

    @Override
    public String toString() {
        return "工种 : " + this.type + " 工资  : " + this.salary + "\n";
    }

}

使用Comparable + TreeSet

import java.util.TreeSet;

/**
 * 测试 TreeSet + java.lang.Comparable
 * 实体类实现Comparable接口的应用 
 * @author 郑鑫
 */
public class TreeSetDemo02 {
    public static void main(String[] args) {
        Worker w1 = new Worker("农名工",1000);
        Worker w2 = new Worker("公务员",3000);
        Worker w3 = new Worker("程序员",5000);

        TreeSet<Worker>employee = new TreeSet<Worker>();

        employee.add(w1); //如果没有实现java.util.Comparable且重写comepareTo方法,就会报错
        employee.add(w2);
        employee.add(w3);

        System.out.println(employee);  

    }
}

使用Comparable + TreeMap

import java.util.TreeMap;

/**
 * TreeMap + Comparable
 * @author 郑鑫
 */
public class TreeMapDemo2 {
    public static void main(String[] args) {
        Worker w1 = new Worker("农名工",1000);
        Worker w2 = new Worker("公务员",3000);
        Worker w3 = new Worker("程序员",5000);

        TreeMap<Worker,String>employee = new TreeMap<Worker,String>();

        employee.put(w1,"bjsxt"); //如果没有实现java.util.Comparable且重写comepareTo方法,就会报错
        employee.put(w2,"bjsxt");
        employee.put(w3,"bjsxt");

        System.out.println(employee.keySet()); 
    }
}