码迷，mamicode.com
首页 > 其他好文 > 详细

10.TreeSet、比较器

时间：2015-10-26 18:44:56      阅读：216      评论：0      收藏：0      [点我收藏+]

标签：

Comparable和Comparator 
Comparable 简介
Comparable 是排序接口。
若一个类实现了Comparable接口，就意味着“该类支持排序”。  即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。
此外，“实现Comparable接口的类的对象”可以用作“有序映射(如TreeMap)”中的键或“有序集合(TreeSet)”中的元素，而不需要指定比较器。
Comparable 定义
Comparable 接口仅仅只包括一个函数，它的定义如下：
复制代码代码如下:

package java.lang;
import java.util.*;
public interface Comparable<T> {
    public int compareTo(T o);
}

说明：
假设我们通过 x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。
Comparator 简介
Comparator 是比较器接口。
我们若需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)；那么，我们可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。
也就是说，我们可以通过“实现Comparator类来新建一个比较器”，然后通过该比较器对类进行排序。
Comparator 定义
Comparator 接口仅仅只包括两个个函数，它的定义如下：
复制代码代码如下:

package java.util;
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

说明：
(01) 若一个类要实现Comparator接口：它一定要实现compareTo(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。
        为什么可以不实现 equals(Object obj) 函数呢？ 因为任何类，默认都是已经实现了equals(Object obj)的。 Java中的一切类都是继承于java.lang.Object，在Object.java中实现了equals(Object obj)函数；所以，其它所有的类也相当于都实现了该函数。
(02) int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”。
Comparator 和 Comparable 比较
Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。
而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
我们不难发现：Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。
我们通过一个测试程序来对这两个接口进行说明。源码如下：
复制代码代码如下:

import java.util.*;
import java.lang.Comparable;
/**
 * @desc "Comparator"和“Comparable”的比较程序。
 *   (01) "Comparable"
 *   它是一个排序接口，只包含一个函数compareTo()。
 *   一个类实现了Comparable接口，就意味着“该类本身支持排序”，它可以直接通过Arrays.sort() 或 Collections.sort()进行排序。
 *   (02) "Comparator"
 *   它是一个比较器接口，包括两个函数：compare() 和 equals()。
 *   一个类实现了Comparator接口，那么它就是一个“比较器”。其它的类，可以根据该比较器去排序。
 *
 *   综上所述：Comparable是内部比较器，而Comparator是外部比较器。
 *   一个类本身实现了Comparable比较器，就意味着它本身支持排序；若它本身没实现Comparable，也可以通过外部比较器Comparator进行排序。
 */
public class CompareComparatorAndComparableTest{
    public static void main(String[] args) {
        // 新建ArrayList(动态数组)
        ArrayList<Person> list = new ArrayList<Person>();
        // 添加对象到ArrayList中
        list.add(new Person("ccc", 20));
        list.add(new Person("AAA", 30));
        list.add(new Person("bbb", 10));
        list.add(new Person("ddd", 40));
        // 打印list的原始序列
        System.out.printf("Original  sort, list:%s\n", list);
        // 对list进行排序
        // 这里会根据“Person实现的Comparable<String>接口”进行排序，即会根据“name”进行排序
        Collections.sort(list);
        System.out.printf("Name      sort, list:%s\n", list);
        // 通过“比较器(AscAgeComparator)”，对list进行排序
        // AscAgeComparator的排序方式是：根据“age”的升序排序
        Collections.sort(list, new AscAgeComparator());
        System.out.printf("Asc(age)  sort, list:%s\n", list);
        // 通过“比较器(DescAgeComparator)”，对list进行排序
        // DescAgeComparator的排序方式是：根据“age”的降序排序
        Collections.sort(list, new DescAgeComparator());
        System.out.printf("Desc(age) sort, list:%s\n", list);
        // 判断两个person是否相等
        testEquals();
    }
    /**
     * @desc 测试两个Person比较是否相等。
     *   由于Person实现了equals()函数：若两person的age、name都相等，则认为这两个person相等。
     *   所以，这里的p1和p2相等。
     *
     *   TODO：若去掉Person中的equals()函数，则p1不等于p2
     */
    private static void testEquals() {
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        if (p1.equals(p2)) {
            System.out.printf("%s EQUAL %s\n", p1, p2);
        } else {
            System.out.printf("%s NOT EQUAL %s\n", p1, p2);
        }
    }
    /**
     * @desc Person类。
     *       Person实现了Comparable接口，这意味着Person本身支持排序
     */
    private static class Person implements Comparable<Person>{
        int age;
        String name;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public int getAge() {
            return age;
        }
        public String toString() {
            return name + " - " +age;
        }
        /**
         * 比较两个Person是否相等：若它们的name和age都相等，则认为它们相等
         */
        boolean equals(Person person) {
            if (this.age == person.age && this.name == person.name)
                return true;
            return false;
        }
        /**
         * @desc 实现 “Comparable<String>” 的接口，即重写compareTo<T t>函数。
         *  这里是通过“person的名字”进行比较的
         */
        @Override
        public int compareTo(Person person) {
            return name.compareTo(person.name);
            //return this.name - person.name;
        }
    }
    /**
     * @desc AscAgeComparator比较器
     *       它是“Person的age的升序比较器”
     */
    private static class AscAgeComparator implements Comparator<Person> {
        @Override 
        public int compare(Person p1, Person p2) {
            return p1.getAge() - p2.getAge();
        }
    }
    /**
     * @desc DescAgeComparator比较器
     *       它是“Person的age的升序比较器”
     */
    private static class DescAgeComparator implements Comparator<Person> {
        @Override 
        public int compare(Person p1, Person p2) {
            return p2.getAge() - p1.getAge();
        }
    }
}

下面对这个程序进行说明。
a) Person类定义。如下：
复制代码代码如下:

private static class Person implements Comparable<Person>{
    int age;
    String name;
        ...
    /** 
     * @desc 实现 “Comparable<String>” 的接口，即重写compareTo<T t>函数。
     *  这里是通过“person的名字”进行比较的
     */
    @Override
    public int compareTo(Person person) {
        return name.compareTo(person.name);
        //return this.name - person.name;
    }   
}

说明：
(01) Person类代表一个人，Persong类中有两个属性：age(年纪) 和 name“人名”。
(02) Person类实现了Comparable接口，因此它能被排序。
b) 在main()中，我们创建了Person的List数组(list)。如下：
复制代码代码如下:

// 新建ArrayList(动态数组)
ArrayList<Person> list = new ArrayList<Person>();
// 添加对象到ArrayList中
list.add(new Person("ccc", 20));
list.add(new Person("AAA", 30));
list.add(new Person("bbb", 10));
list.add(new Person("ddd", 40));

c) 接着，我们打印出list的全部元素。如下：
复制代码代码如下:

// 打印list的原始序列
System.out.printf("Original sort, list:%s\n", list);

d) 然后，我们通过Collections的sort()函数，对list进行排序。
    由于Person实现了Comparable接口，因此通过sort()排序时，会根据Person支持的排序方式，即 compareTo(Person person) 所定义的规则进行排序。如下：
复制代码代码如下:

// 对list进行排序
// 这里会根据“Person实现的Comparable<String>接口”进行排序，即会根据“name”进行排序
Collections.sort(list);
System.out.printf("Name sort, list:%s\n", list);

e) 对比Comparable和Comparator
    我们定义了两个比较器 AscAgeComparator 和 DescAgeComparator，来分别对Person进行 升序 和 降低 排序。
e.1) AscAgeComparator比较器
它是将Person按照age进行升序排序。代码如下：
复制代码代码如下:

/**
 * @desc AscAgeComparator比较器
 *       它是“Person的age的升序比较器”
 */
private static class AscAgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getAge() - p2.getAge();
    }
}

e.2) DescAgeComparator比较器
它是将Person按照age进行降序排序。代码如下：
复制代码代码如下:

/**
 * @desc DescAgeComparator比较器
 *       它是“Person的age的升序比较器”
 */
private static class DescAgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p2.getAge() - p1.getAge();
    }
}

f) 运行结果
运行程序，输出如下：
复制代码代码如下:

Original  sort, list:[ccc - 20, AAA - 30, bbb - 10, ddd - 40]
Name      sort, list:[AAA - 30, bbb - 10, ccc - 20, ddd - 40]
Asc(age)  sort, list:[bbb - 10, ccc - 20, AAA - 30, ddd - 40]
Desc(age) sort, list:[ddd - 40, AAA - 30, ccc - 20, bbb - 10]
eee - 100 EQUAL eee - 100


 
TreeSet

1、概述：TreeSet可以对Set集合中的元素进行排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0.

 * TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法
 *
 * Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序)
 * 
 * 如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口
 *   在类上implement Comparable
 *   重写compareTo()方法
 *   在方法内定义比较算法, 根据大小关系, 返回正数负数或零
 *   在使用TreeSet存储对象的时候, add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储
 */

2.TreeSet是依靠TreeMap来实现的。
TreeSet是一个有序集合，TreeSet中的元素将按照升序排列(指排序的顺序)，缺省是按照自然排序进行排列，意味着TreeSet中的元素要实现Comparable接口。或者有一个自定义的比较器。
我们可以在构造TreeSet对象时，传递实现Comparator接口的比较器对象。

技术分享
import java.util.Iterator;
import java.util.*;

public class TreeSetTest {
    public static void main(String[] args) {
        Set ts = new TreeSet();
        ts.add("abc");
        ts.add("xyz");
        ts.add("rst");
        Iterator it = ts.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
技术分享

输出结果：

abc

rst

xyz

打印结果不是和先前加入的顺序一样，它是按照一个字母的排序法进行排序的。这是因为String 类实现了Comparable接口。

如果我们自己定义的一个类的对象要加入到TreeSet当中，那么这个类必须要实现Comparable接口。

3、关于二叉树，见图说话：

技术分享

技术分享
二叉树的存储方式就像树叉一样，所以称为二叉树。它的特点就是把大的数放在右边，小的数放在左边，取值时会按照从小到大的顺序取值。如果数据较多，二叉树会自动折中，然后再去判断，如图中就会折中到第五个位置上。这样就大大提高了存取的效率。

4、保证元素唯一性的依据：
实现的compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。

5、排序的两种实现方式，让元素本身具备比较性（Comparable）和让容器具备比较性(比较器Comparator)。

1）让元素本身具备比较性，有些元素本身就具备比较性如String和Integer，这是因为他们实现Comparable接口，这种排序方式也称为自然顺序排序。下面的方法用在list也可以，因为接口是定义在要比较的对象里的

    1. public class TreeSetDemo {

    3.  public static void main(String[] args) {
    4.   TreeSet ts = new TreeSet(//new ComparatorByName());//传入了下边的ComparatorByName()就可以直接按姓名比较
    5.  person有了自然排序，treeset有了比较器，以比较器为主，比较器常用（结合下边看）
    6. //按字母大小自然排序
    7. public static void demo1() {
    8.   TreeSet ts = new TreeSet();
    9.  
    10.   ts.add("abc");
    11.   ts.add("zaa");
    12.   ts.add("aa");
    13.   ts.add("nba");
    14.   ts.add("cba");
    15.  
    16.   Iterator it = ts.iterator();
    17.  
    18.   while(it.hasNext()){
    19.    System.out.println(it.next());
    20.   }
    21.  }
    23.   /*
    24.    * 如果以Person对象年龄进行从小到大的排序。
    25.    * 下面代码异常，排序就需要比较，可是Person本身没有比较功能
    26.    * 
    27.    */
    29.   ts.add(new Person("zhangsan",28));
    30.   ts.add(new Person("lisi",21));
    31.   ts.add(new Person("zhouqi",29));
    32.   ts.add(new Person("zhaoliu",25));
    33.   ts.add(new Person("wangu",24));
    34.   Iterator it = ts.iterator();
    35.   while(it.hasNext()){
    36.    Person p = (Person)it.next();
    37.    System.out.println(p.getName()+":"+p.getAge());
    38.   }
    39.   }
    40. }


    技术分享

    上面这种方式是元素本身就具备比较性，但是要是没有具备比较性那么我们就必须自己去实现comparable接口去重写compareTo方法，自己建立需要的比较性。根本不看hashcode和equals.
    Java String.compareTo()，此方法如果这个字符串是等参数字符串那么返回值0，如果这个字符串是按字典顺序小于字符串参数那么返回小于0的值，如果此字符串是按字典顺序大于字符串参数那么一个大于0的值
    示例1：
    1. public class Person /*extends Object*/ implements Comparable {
    2.  private String name;
    3.  private int age;
    4.  public Person() {
    5.   super();
    6.  }
    7.  public Person(String name, int age) {
    8.   super();
    9.   this.name = name;
    10.   this.age = age;
    11.  }
    12.  
    13.  public void setName(String name) {
    14.   this.name = name;
    15.  }
    16.  public int getAge() {
    17.   return age;
    18.  }
    19.  public void setAge(int age) {
    20.   this.age = age;
    21.  }
    22.  public String toString(){
    23.   return name+":"+age;
    24.  }
    25.  
    27. @Override
    28.  public int compareTo(Object o) {
    29.   Person p = (Person)o;//凡事强转都需要健壮性判断
    30.   int  temp = this.age-p.age;//如果年龄一样按姓名排
    31.   return temp==0?this.name.compareTo(p.name):temp;
    32. //	 int  temp = this.name.compareTo(p.name);按姓名排
    33. //	 return temp==0?this.age-p.age:temp;
    34.   /*
    35.   if(this.age>p.age)
    36.    return 1;
    37.   if(this.age<p.age)
    38.    return -1;
    39.   else{//=0时继续按次要条件（姓名）比较
    40.       return this.name.compareTo(p.name);比较名字string里也有compareTo
    41.   }
    42.   */
    43.   }
    44.  }

    技术分享

    2)：让容器具备比较性,定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。当两种排序都存在时，以比较器为主。实现方式：定义一个类，实现Comparator接口，覆盖compare方法。
    1.  * 需求：对字符串进行按长度排序  
    2.  * 分析：字符串本身具备比较性，但是是按自然顺序进行的排序，所以需要对排序方式进行重新定义,所以需要让集合具备比较性  
    3.  * 使用比较器Comparator，覆盖compare 方法
    4.  */  
    5. public class TestTreeSet {  
    6.     public static void main(String[] args) {  
    7.         TreeSet<ComString> ts = new TreeSet<ComString>(new Mycompare());  
    8.         ts.add(new ComString("asd"));  
    9.         ts.add(new ComString("df"));  
    10.         ts.add(new ComString("dk"));  
    11.         ts.add(new ComString("jkkggd"));  
    12.         ts.add(new ComString("sfsfssgds"));  
    13.   
    14.          Iterator it = ts.iterator();
    15.           while(it.hasNext()){
    16.         System.out.println(it.next());
    17.   }
    18.  }
    19. }  
    20.   
    21. class Mycompare implements Comparator<ComString> {  
    23.     public int compare(ComString o1, ComString o2) {  
    24.         int num = o1.getS().length() - o2.getS().length();  
    25.         if (num == 0) {  
    26.             return o1.getS().compareTo(o2.getS());  
    27.         }  
    28.         return num;  
    29.     }  
    30. }  
    31.   
    32. class ComString {  
    33.     private String s;  
    34.   
    35.     ComString(String s) {  
    36.         this.s = s;  
    37.     }  
    38.   
    39.     public String getS() {  
    40.         return s;  
    41.     }  
    42.   
    43.     public void setS(String s) {  
    44.         this.s = s;  
    45.     }  
    46.

    技术分享





















    10.TreeSet、比较器

    标签：

    原文地址：http://www.cnblogs.com/liuyu0529/p/4911893.html
    踩
    (0)
    赞
    (0)
       
    举报
    评论 一句话评论（0）
    登录后才能评论！
    分享档案
    更多>
    2021年07月29日 (22)
    2021年07月28日 (40)
    2021年07月27日 (32)
    2021年07月26日 (79)
    2021年07月23日 (29)
    2021年07月22日 (30)
    2021年07月21日 (42)
    2021年07月20日 (16)
    2021年07月19日 (90)
    2021年07月16日 (35)
    周排行
    mamicode.com排行更多图片
    更多
    友情链接
    兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
    关于我们 - 联系我们 - 留言反馈
    © 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
    迷上了代码！