Set 的其他实现类:TreeSet

  1. 向 TreeSet 中添加的元素必须是同一个类
  2. 可以按照添加进集合中的元素的指定顺序遍历(仍然是“存储无序”的),如 String、包装类等默认按照从小到大的顺序遍历。
  3. 当向 TreeSet 中添加自定义类的对象时,有两种排序方法:自然排序、定制排序
  4. 自然排序:要求该类(要添加进 TreeSet 中的元素所对应的类)实现 java.lang.Comparable 接口(不实现的话不能添加)并实现其 compareTo(Object obj) 方法(非自定义类一般都已经实现了该方法),在该方法中指明按照自定义类的哪个属性进行排序的,该方法返回0时表示两元素用作排序的那个属性是相同的,返回负数代表当前元素的用作排序的那个属性是“字典式地”小于参数元素的用作排序的那个属性的,返回正数代表当前元素的用作排序的那个属性是“字典式地”大于参数元素的用作排序的那个属性的(在设计中首选那个不可能重复的属性来排序,以避免“A属性相同,再按B属性排序”的情况)
  5. 当向 TreeSet 中添加元素时,首先按照 compareTo( ) 进行比较,一旦返回0,虽然此时仅仅是指定的那个属性一样,但程序会认为两个对象是相同的,后面的对象不能被添加,为避免此情况发生,要求 compareTo( ) 与 equals( ) 和 hashCode( ) 保持一致
  6. 定制排序:调用TreeSet(Comparator comparator)  构造器构造 TreeSet 的对象,其中 comparator 是 java.util.Comparator 接口的实现类,并且该实现类的 compare(T o1, T o2)  方法指明了排序的根据,此时也要求 compare(T o1, T o2) 与 equals( ) 和 hashCode( ) 保持一致(理由同第5点)

一般不会让一个类即实现 Comparable 又定制 Comparator(这种情况以定制排序为准)

关于两种排序,参考一下代码:

  • 自然排序
  1. public class TestTreeSet {
  2. public static void main(String[] args) {
  3. TreeSet t = new TreeSet();
  4. t.add(new Person(12, "b"));
  5. t.add(new Person(12, "d"));
  6. t.add(new Person(11, "c"));
  7. t.add(new Person(10, "b"));
  8. System.out.println(t);// [Person [id=10, name=b],
  9. // Person [id=11, name=c],
  10. // Person [id=12, name=b],
  11. // Person [id=12, name=d]]
  12. }
  13. }
  14. class Person implements Comparable {
  15. private Integer id;
  16. private String name;
  17. public Person(int id, String name) {
  18. super();
  19. this.id = id;
  20. this.name = name;
  21. }
  22. public Person() {
  23. super();
  24. }
  25. public Integer getId() {
  26. return id;
  27. }
  28. public void setId(int id) {
  29. this.id = id;
  30. }
  31. public String getName() {
  32. return name;
  33. }
  34. public void setName(String name) {
  35. this.name = name;
  36. }
  37. @Override
  38. public int hashCode() {
  39. final int prime = 31;
  40. int result = 1;
  41. result = prime * result + id;
  42. result = prime * result + ((name == null) ? 0 : name.hashCode());
  43. return result;
  44. }
  45. @Override
  46. public boolean equals(Object obj) {
  47. if (this == obj)
  48. return true;
  49. if (obj == null)
  50. return false;
  51. if (getClass() != obj.getClass())
  52. return false;
  53. Person other = (Person) obj;
  54. if (id != other.id)
  55. return false;
  56. if (name == null) {
  57. if (other.name != null)
  58. return false;
  59. } else if (!name.equals(other.name))
  60. return false;
  61. return true;
  62. }
  63. @Override
  64. public String toString() {
  65. return "Person [id=" + id + ", name=" + name + "]";
  66. }
  67. @Override
  68. public int compareTo(Object o) {
  69. if (o instanceof Person) {
  70. Person p = (Person) o;
  71. int i = this.getId().compareTo(p.getId());
  72. if (i == 0) {
  73. return this.getName().compareTo(p.getName());
  74. }
  75. return i;
  76. }
  77. return 0;
  78. }
  79. }
  • 定制排序
  1. public class TestTreeSet {
  2. public static void main(String[] args) {
  3. TreeSet t = new TreeSet(new Comparator() {
  4. @Override
  5. public int compare(Object o1, Object o2) {
  6. if (o1 instanceof Person && o2 instanceof Person) {
  7. Person p1 = (Person) o1;
  8. Person p2 = (Person) o2;
  9. int i = p1.getId().compareTo(p2.getId());
  10. if (i == 0) {
  11. return p1.getName().compareTo(p2.getName());
  12. }
  13. return i;
  14. }
  15. return 0;
  16. }
  17. });
  18. t.add(new Person(12, "b"));
  19. t.add(new Person(12, "a"));
  20. t.add(new Person(11, "c"));
  21. t.add(new Person(10, "b"));
  22. System.out.println(t);// [Person [id=10, name=b],
  23. // Person [id=11, name=c],
  24. // Person [id=12, name=a],
  25. // Person [id=12, name=b]]
  26. }
  27. }
  28. class Person {
  29. private Integer id;
  30. private String name;
  31. public Person(int id, String name) {
  32. super();
  33. this.id = id;
  34. this.name = name;
  35. }
  36. public Person() {
  37. super();
  38. }
  39. public Integer getId() {
  40. return id;
  41. }
  42. public void setId(int id) {
  43. this.id = id;
  44. }
  45. public String getName() {
  46. return name;
  47. }
  48. public void setName(String name) {
  49. this.name = name;
  50. }
  51. @Override
  52. public int hashCode() {
  53. final int prime = 31;
  54. int result = 1;
  55. result = prime * result + id;
  56. result = prime * result + ((name == null) ? 0 : name.hashCode());
  57. return result;
  58. }
  59. @Override
  60. public boolean equals(Object obj) {
  61. if (this == obj)
  62. return true;
  63. if (obj == null)
  64. return false;
  65. if (getClass() != obj.getClass())
  66. return false;
  67. Person other = (Person) obj;
  68. if (id != other.id)
  69. return false;
  70. if (name == null) {
  71. if (other.name != null)
  72. return false;
  73. } else if (!name.equals(other.name))
  74. return false;
  75. return true;
  76. }
  77. @Override
  78. public String toString() {
  79. return "Person [id=" + id + ", name=" + name + "]";
  80. }
  81. }
时间: 2024-12-28 05:59:21

Set 的其他实现类:TreeSet的相关文章

JavaSE入门学习36:Java集合框架之Set接口及其实现类HashSet和TreeSet

一Set接口 Set接口可以与数学中的集合的概念相对应.Set接口是Collection接口的子接口,Set接口里多个对象之间没有明 显的顺序.具体详细方法请参考API文档(可见身边随时带上API文档有多重要),基本与Collection接口中定义的方法相 同.只是行为不同(Set不允许包含重复元素). Set集合不允许重复元素,是因为Set判断两个对象相同不是使用==运算符,而是根据equals()方法.即两个对象 用equals()方法比较返回true,Set就不能接受两个相等的对象. 我们

Set的常用实现类HashSet和TreeSet

Set HashSet public static void main(String[] args) { //不可以重复  并且是无序的  //自然排序  从A-Z  //eqauls从Object继承,默认比较地址//  Set<String> set= new HashSet<>();//  set.add("zs");//  set.add("ls");//  set.add("ww");//  set.add(&q

HashSet,TreeSet和LinkedHashSet的区别

Set接口Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false.Set判断两个对象相同不是使用==运算符,而是根据equals方法.也就是说,只要两个对象用equals方法比较返回true,Set就不 会接受这两个对象. HashSet: 顺序是不确定性的. LinkedHashSet:按照输入的顺序进行输出. TreeSet:SortedSet 接口的唯一实现类,保证集合元素处于排序状态. 1.HashSetHashSet有以下特点    不能保证元素的

HashSet和TreeSet

Set接口Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false.Set判断两个对象相同不是使用==运算符,而是根据equals方法.也就是说,只要两个对象用equals方法比较返回true,Set就不 会接受这两个对象. HashSetHashSet有以下特点? 不能保证元素的排列顺序,顺序有可能发生变化? 不是同步的? 集合元素可以是null,但只能放入一个null当向HashSet结合中存入一个元素时,HashSet会调用该对象的hashCode()方

linkedhashSet和hashSet和TreeSet的区别(转)

Set接口Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false.Set判断两个对象相同不是使用==运算符,而是根据equals方法.也就是说,只要两个对象用equals方法比较返回true,Set就不 会接受这两个对象. HashSetHashSet有以下特点? 不能保证元素的排列顺序,顺序有可能发生变化? 不是同步的? 集合元素可以是null,但只能放入一个null当向HashSet结合中存入一个元素时,HashSet会调用该对象的hashCode()方

Java——HashSet和TreeSet的区别

HashSetHashSet有以下特点? 不能保证元素的排列顺序,顺序有可能发生变化? 不是同步的? 集合元素可以是null,但只能放入一个null当向HashSet集合中存入一个元素时,HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,然后根据 hashCode值来决定该对象在HashSet中存储位置.简单的说,HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等,并且两个对象的hashCode()方法返回值相 等注意,如果要把一个

Java学习笔记_22_Set接口的实现类

22.Set接口的实现类: Set接口存放的元素是无序的且不包括反复元素. 1>实现类HashSet: HashSet类依据元素的哈希码进行存放,取出时也能够依据哈希码高速找到.HashSet不保存元素的加入的顺序. 样例: import java.util.HashSet; import java.util.Iterator; public class Student { public static void main(String[] args) { HashSet<String>

常用的类、文件操作

异常与异常处理 异常简介 在Java中,所有的异常都有一个共同的祖先Throwable(可抛出).Throwable指定代码中可用异常传播机制通过Java应用程序传输任何问题的共性. 处理异常机制 在 Java 应用程序中,异常处理机制为:抛出异常,捕捉异常. 抛出异常:当一个方法出现错误引发异常时,方法创建异常对象并交付运行时系统,异常对象中包含了异常类型和异常出现时的程序状态等异常信息.运行时系统负责寻找处置异常的代码并执行. 捕获异常:在方法抛出异常之后,运行时系统将转为寻找合适的异常处理

Set下面HashSet,TreeSet和LinkedHashSet的区别

Set接口Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false.Set判断两个对象相同不是使用==运算符,而是根据equals方法.也就是说,只要两个对象用equals方法比较返回true,Set就不 会接受这两个对象. HashSetHashSet有以下特点? 不能保证元素的排列顺序,顺序有可能发生变化? 不是同步的? 集合元素可以是null,但只能放入一个null当向HashSet结合中存入一个元素时,HashSet会调用该对象的hashCode()方

java TreeSet 应用

本文主要是介绍一下java集合中的比较重要的Set接口下的可实现类TreeSet TreeSet类,底层用二叉树的数据结构 * 集合中以有序的方式插入和抽取元素. * 添加到TreeSet中的元素必须是可以排序的 * 保证数据的唯一性: * 第一种:让添加的类自身具有可比较性, * 实现Comparable接口中的CompareTo()方法 首先建立一个添加的类型,如下定义,让元素自身具备可比较性 * 添加类中实现Comparable方法中CompareTo()方法 * 按对象的年龄进行排序存储