qileilove

blog已经转移至github,大家请访问 http://qaseven.github.io/

Java集合框架总结：TreeSet类的排序问题

　程序运行结果：

true 
[TreeSet.Z@1fb8ee3, TreeSet.Z@1fb8ee3] 
9

　　说明：

　　程序中把同一个对象添加了两次，因为z1对象的equals()方法总是返回false，而且compareTo(Object obj)方法总是返回1。这样TreeSet会认为z1对象和它自己也不相同，因此TreeSet中添加两个z1对象。而TreeSet对象保存的两个元素实际上是同一个元素。所以当修改TreeSet集合里第一个元素的age属性后，该TreeSet集合里最后一个元素的age属性也随之改变了。

　　总结：当需要把一个对象放入TreeSet中时，重写该对象对应类的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致结果，其规则是：如果两个对象通过equals方法比较返回true时，这两个对象通过compareTo（Object obj）方法比较应返回0。

　　如果两个对象通过equals方法比较返回true，但这两个对象通过compareTo(Object obj)方法比较不返回0时，这将导致TreeSet将会把这两个对象保存在不同位置，从而两个对象都可以添加成功，这与Set集合的规则有点出入。

　　如果两个对象通过compareTo(Object obj)方法比较返回0时，但它们通过equals方法比较返回false时将更麻烦：因为两个对象通过compareTo（Object obj）方法比较相等，TreeSet将试图把它们保存在同一个位置，但实际上又不行（否则将只剩下一个对象），所以处理起来比较麻烦。

　　如果向TreeSet中添加一个可变对象后，并且后面程序修改了该可变对象的属性，导致它与其他对象的大小顺序发生改变，但TreeSet不会再次调整它们的顺序，甚至可能导致TreeSet中保存这两个对象，它们通过equals方法比较返回true，compareTo（Object obj）方法比较返回0.

　　如下程序所示：

  1. class R  
  2. {  
  3. int count;  
  4. public R(int count)  
  5. {  
  6. this.count = count;  
  7. }  
  8. public String toString()  
  9. {  
  10. return "R(count属性:" + count + ")";  
  11. }  
  12. public boolean equals(Object obj)  
  13. {  
  14. if (obj instanceof R)  
  15. {  
  16. R r = (R)obj;  
  17. if (r.count == this.count)  
  18. {  
  19. return true;  
  20. }  
  21. }  
  22. return false;  
  23. }  
  24. public int hashCode()  
  25. {  
  26. return this.count;  
  27. }  
  28. }  
  29. public class TestHashSet2  
  30. {  
  31. public static void main(String[] args)  
  32. {  
  33. HashSet hs = new HashSet();  
  34. hs.add(new R(5));  
  35. hs.add(new R(-3));  
  36. hs.add(new R(9));  
  37. hs.add(new R(-2));  
  38. //打印TreeSet集合，集合元素是有序排列的  
  39. System.out.println(hs);  
  40. //取出第一个元素  
  41. Iterator it = hs.iterator();  
  42. R first = (R)it.next();  
  43. //为第一个元素的count属性赋值  
  44. first.count = -3;  
  45. //再次输出count将看到TreeSet里的元素处于无序状态  
  46. System.out.println(hs);  
  47. hs.remove(new R(-3));  
  48. System.out.println(hs);  
  49. //输出false  
  50. System.out.println("hs是否包含count为-3的R对象？" + hs.contains(new R(-3)));  
  51. //输出false  
  52. System.out.println("hs是否包含count为5的R对象？" + hs.contains(new R(5)));  
  53.  
  54. }  
  55. }

TreeSet支持两种排序方法：自然排序和定制排序。TreeSet默认采用自然排序。

　　1、自然排序

　　TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系，然后将集合元素按升序排列，这种方式就是自然排序。（比较的前提：两个对象的类型相同）。

　　java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现该接口的类必须实现该方法，实现了该接口的类的对象就可以比较大小。当一个对象调用该方法与另一个对象进行比较，例如obj1.comparTo(obj2),如果该方法返回0，则表明这两个对象相等；如果返回一个正整数，则表明obj1大于obj2；如果该方法返回一个负整数，则表明obj1小于obj2.

　　java常用类实现Comparable接口，并提供了比较大小的标准。实现Comparable接口的常用类：

　　● BigDecimal、BigIneger以及所有数值型对应包装类：按它们对应的数值的大小进行比较。

　　● Character：按字符的UNICODE值进行比较。

　　● Boolean：true对应的包装类实例大于false对应的包装类实例。

　　● String：按字符串中字符的UNICODE值进行比较。

　　● Date、Time：后面的时间、日期比前面的时间、日期大。

　　如果试图把一个对象添加进TreeSet时，则该对象的类必须实现Comparable接口。

　　如下程序则会报错：

  1. class Err  
  2. {  
  3. }  
  4. public class TestTreeSetError  
  5. {  
  6. public static void main(String[] args)  
  7. {  
  8. TreeSet ts = new TreeSet();  
  9. //向TreeSet集合中添加两个Err对象 
  10. ts.add(new Err());  
  11. ts.add(new Err());  
  12. }  
  13. }

　　说明：

　　上面程序试图向TreeSet集合中添加2个Err对象，添加第一个对象时，TreeSet里没有任何元素，所以没有问题；当添加第二个Err对象时，TreeSet就会调用该对象的compareTo(Object obj)方法与集合中其他元素进行比较——如果对应的类没有实现Comparable接口，则会引发ClassCastException异常。而且当试图从TreeSet中取出元素第一个元素时，依然会引发ClassCastException异常。

　　当采用compareTo(Object obj)方法比较对象时，都需要将被比较对象obj强制类型转换成相同类型，因为只有相同类的两个实例才能比较大小。即向TreeSet中添加的应该是同一个类的对象，否则会引发ClassCastException异常。例如，当向TreeSet中添加一个字符串对象，这个操作完全正常。当添加第二个Date对象时，TreeSet就好调用该对象的compareTo(Object obj)方法与集合中其他元素进行比较，则此时程序会引发异常。

　　在实际编程中，程序员可以定义自己的类向TreeSet中添加多种类型的对象，前提是用户自定义类实现了Comparable接口，实现该接口时在实现compareTo(Object obj)方法时没有进行强制类型转换。但当操作TreeSet里的集合数据时，不同类型的元素依然会发生ClassCastExceptio异常。（认真阅读下就会明白)

　　当把一个对象加入TreeSet集合中时，TreeSet调用该对象的compareTo(Object obj)方法与容器中的其他对象比较大小，然后根据红黑树算法决定它的存储位置。如果两个对象通过compareTo(Object obj)比较相等，TreeSet即认为它们存储同一位置。

　　对于TreeSet集合而言，它判断两个对象不相等的标准是：两个对象通过equals方法比较返回false，或通过compareTo（Object obj）比较没有返回0——即使两个对象时同一个对象，TreeSet也会把它们当成两个对象进行处理。

　　如下程序所示：

  1. //Z类，重写了equals方法，总是返回false， 
  2. //重写了compareTo(Object obj)方法，总是返回正整数 
  3. class Z implements Comparable  
  4. {  
  5. int age;  
  6. public Z(int age)  
  7. {  
  8. this.age = age;  
  9. }  
  10. public boolean equals(Object obj)  
  11. {  
  12. return false;  
  13. }  
  14. public int compareTo(Object obj)  
  15. {  
  16. return 1;  
  17. }  
  18. }  
  19. public class TestTreeSet  
  20. {  
  21. public static void main(String[] args)  
  22. {  
  23. TreeSet set = new TreeSet();  
  24. Z z1 = new Z(6);  
  25. set.add(z1);  
  26. System.out.println(set.add(z1));  
  27. //下面输出set集合，将看到有2个元素 
  28. System.out.println(set);  
  29. //修改set集合的第一个元素的age属性 
  30. ((Z)(set.first())).age = 9;  
  31. //输出set集合的最后一个元素的age属性，将看到也变成了9 
  32. System.out.println(((Z)(set.last())).age);  
  33. }  
  34. }


　程序运行结果：

true 
[TreeSet.Z@1fb8ee3, TreeSet.Z@1fb8ee3] 
9

　　说明：

　　程序中把同一个对象添加了两次，因为z1对象的equals()方法总是返回false，而且compareTo(Object obj)方法总是返回1。这样TreeSet会认为z1对象和它自己也不相同，因此TreeSet中添加两个z1对象。而TreeSet对象保存的两个元素实际上是同一个元素。所以当修改TreeSet集合里第一个元素的age属性后，该TreeSet集合里最后一个元素的age属性也随之改变了。

　　总结：当需要把一个对象放入TreeSet中时，重写该对象对应类的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致结果，其规则是：如果两个对象通过equals方法比较返回true时，这两个对象通过compareTo（Object obj）方法比较应返回0。

　　如果两个对象通过equals方法比较返回true，但这两个对象通过compareTo(Object obj)方法比较不返回0时，这将导致TreeSet将会把这两个对象保存在不同位置，从而两个对象都可以添加成功，这与Set集合的规则有点出入。

　　如果两个对象通过compareTo(Object obj)方法比较返回0时，但它们通过equals方法比较返回false时将更麻烦：因为两个对象通过compareTo（Object obj）方法比较相等，TreeSet将试图把它们保存在同一个位置，但实际上又不行（否则将只剩下一个对象），所以处理起来比较麻烦。

　　如果向TreeSet中添加一个可变对象后，并且后面程序修改了该可变对象的属性，导致它与其他对象的大小顺序发生改变，但TreeSet不会再次调整它们的顺序，甚至可能导致TreeSet中保存这两个对象，它们通过equals方法比较返回true，compareTo（Object obj）方法比较返回0.

　　如下程序所示：

  1. class R  
  2. {  
  3. int count;  
  4. public R(int count)  
  5. {  
  6. this.count = count;  
  7. }  
  8. public String toString()  
  9. {  
  10. return "R(count属性:" + count + ")";  
  11. }  
  12. public boolean equals(Object obj)  
  13. {  
  14. if (obj instanceof R)  
  15. {  
  16. R r = (R)obj;  
  17. if (r.count == this.count)  
  18. {  
  19. return true;  
  20. }  
  21. }  
  22. return false;  
  23. }  
  24. public int hashCode()  
  25. {  
  26. return this.count;  
  27. }  
  28. }  
  29. public class TestHashSet2  
  30. {  
  31. public static void main(String[] args)  
  32. {  
  33. HashSet hs = new HashSet();  
  34. hs.add(new R(5));  
  35. hs.add(new R(-3));  
  36. hs.add(new R(9));  
  37. hs.add(new R(-2));  
  38. //打印TreeSet集合，集合元素是有序排列的  
  39. System.out.println(hs);  
  40. //取出第一个元素  
  41. Iterator it = hs.iterator();  
  42. R first = (R)it.next();  
  43. //为第一个元素的count属性赋值  
  44. first.count = -3;  
  45. //再次输出count将看到TreeSet里的元素处于无序状态  
  46. System.out.println(hs);  
  47. hs.remove(new R(-3));  
  48. System.out.println(hs);  
  49. //输出false  
  50. System.out.println("hs是否包含count为-3的R对象？" + hs.contains(new R(-3)));  
  51. //输出false  
  52. System.out.println("hs是否包含count为5的R对象？" + hs.contains(new R(5)));  
  53.  
  54. }  
  55. }


　　程序运行结果：

[R(count属性:-3), R(count属性:-2), R(count属性:5), R(count属性:9)]
[R(count属性:20), R(count属性:-2), R(count属性:5), R(count属性:-2)]
[R(count属性:20), R(count属性:-2), R(count属性:5), R(count属性:-2)]
[R(count属性:20), R(count属性:-2), R(count属性:-2)]

　　说明：

　　上面程序中的R对象是一个正常重写了equals方法和comparable方法类，这两个方法都以R对象的count属性作为判断的依据。可以看到程序第一次输出的结果是有序排列的。当改变R对象的count属性，程序的输出结果也发生了改变，而且包含了重复元素。一旦改变了TreeSet集合里可变元素的属性，当再视图删除该对象时，TreeSet也会删除失败（甚至集合中原有的、属性没被修改，但与修改后元素相等的元素也无法删除），所以删除count

　　为-2的R对象时，没有任何元素被删除；程序可以删除count为5的R对象，这表明TreeSet可以删除没有被修改属性、且不与其他被修改属性的对象重复的对象。

　　总结：与HashSet在处理这些对象时将非常复杂，而且容易出错。为了让程序更具健壮，推荐HashSet和TreeSet集合中只放入不可变对象。

　　2、定制排序

　　TreeSet的自然排序是根据集合元素的大小，TreeSet将他们以升序排列。如果需要实现定制排序，例如降序，则可以使用Comparator接口。该接口里包含一个int compare（T o1， T o2）方法，该方法用于比较o1和o2的大小。

　　如果需要实现定制排序，则需要在创建TreeSet集合对象时，并提供一个Comparator对象与该TreeSet集合关联，由该Comparator对象负责集合元素的排序逻辑。

　　如下程序所示：

  1. class M {  
  2. int age;  
  3.  
  4. public M(int age) {  
  5. this.age = age;  
  6. }  
  7.  
  8. public String toString() {  
  9. return "M对象（age：" + age + ")";  
  10. }  
  11. }  
  12.  
  13. public class TestTreeSet3 {  
  14. public static void main(String[] args) {  
  15. TreeSet ts = new TreeSet(new Comparator() {  
  16. public int compare(Object o1, Object o2) {  
  17.  
  18. M m1 = (M) o1;  
  19. M m2 = (M) o2;  
  20.  
  21. if (m1.age > m2.age) {  
  22. return -1;  
  23. } else if (m1.age == m2.age) {  
  24. return 0;  
  25. } else {  
  26. return 1;  
  27. }  
  28. }  
  29. });  
  30. ts.add(new M(5));  
  31. ts.add(new M(-3));  
  32. ts.add(new M(9));  
  33. System.out.println(ts);  
  34. }  
  35. }

　　程序运行结果：

[M对象（age：9), M对象（age：5), M对象（age：-3)]

　　说明：

　　上面程序中创建了一个Comparator接口的匿名内部类对象，该对象负责ts集合的排序。所以当我们把M对象添加到ts集合中时，无须M类实现Comparable接口，因为此时TreeSet无须通过M对象来比较大小，而是由与TreeSet关联的Comparator对象来负责集合元素的排序。使用定制排序时，TreeSet对集合元素排序时不管集合元素本身的大小，而是由Comparator对象负责集合元素的排序规则。




posted on 2012-05-04 11:51 顺其自然EVO 阅读(295) 评论(0)  编辑  收藏


只有注册用户登录后才能发表评论。
网站导航:
 
<2012年5月>
日一二三四五六
293012345
6789101112
13141516171819
20212223242526
272829303112
3456789

导航

统计

常用链接

留言簿(55)

随笔分类

随笔档案

文章分类

文章档案

搜索

最新评论

阅读排行榜

评论排行榜