TreeSet集合(43)

TreeSet集合

1. TreeSet特点:无需不可重复但是可以按照元素的大写进行排序
   示例代码01：

           // 创建TressSet集合
           SortedSet ss1 = new TreeSet();
           // 添加元素
           ss1.add(111); // 自动装箱 Integer类型装箱
           ss1.add(222);
           ss1.add(1);
           ss1.add(0);
           ss1.add(9999);
           ss1.add(555);
           // 遍历
           Iterator i = ss1.iterator(); // 创建迭代器
           while (i.hasNext()) {
               Object o = i.next();
               System.out.println(o);
               // 0
               // 1
               // 111
               // 222
               // 555
               // 9999
               // 输出以上顺序
           }
           // 创建TressSet集合
           SortedSet ss2 = new TreeSet();
           // 添加元素
           String tm1 = "2020-01-30";
           String tm2 = "2021-03-20";
           String tm3 = "2025-10-5";
           String tm4 = "2026-06-30";
           String tm5 = "2029-02-30";
           // 创建格式化日期对象
           SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd");
           Date q1 = s1.parse(tm1);
           Date q2 = s1.parse(tm2);
           Date q3 = s1.parse(tm3);
           Date q4 = s1.parse(tm4);
           Date q5 = s1.parse(tm5);
           //添加元素
           ss2.add(q1);
           ss2.add(q2);
           ss2.add(q3);
           ss2.add(q4);
           ss2.add(q5);
           // 遍历
           Iterator i2 = ss2.iterator(); // 创建迭代器
           while (i2.hasNext()) {
               Object o = i2.next();
               // 如果直接写以下方法，不保险，因为如果传过来的不是Date类型则会直接报错
               // System.out.println(o instanceof Student);
               if (o instanceof Date) {
                   Date d = (Date)o;
                   System.out.println(s1.format(o));
                   // 2020-01-30
                   // 2021-03-20
                   // 2025-10-05
                   // 2026-06-30
                   // 2029-03-02
                   // 输出以上顺序
               }
           }
   

2. TreeSet实现自动排序原理：

   • 示例代码01：

     // 创建TressSet自动排序01
     /**
      * Sortedset集合存储元素实现自动排序原因：被存储的元素实现了Comparable接口，
      * SUN编写 TreeSet集合在添加元素的时候，会调用compareTo方法
      */
     public class SortedSetTest02 {
         public static void main(String[] args) {
             // 创建TressSet集合
             SortedSet s1 = new TreeSet();
             // 添加元素
             Student5 a1 = new Student5(2);
             Student5 a2 = new Student5(89);
             Student5 a3 = new Student5(10);
             Student5 a4 = new Student5(8);
             s1.add(a1);
             s1.add(a2);
             s1.add(a3);
             s1.add(a4);
             // 遍历
             Iterator i = s1.iterator();  // 创建迭代器
             while (i.hasNext()) {
                 System.out.println(i.next());
                 /*
                  * 以上程序报错：ClassCastException //类转换错误
                  * SortedSet集合存储元素可以自动排序的原理：
                  * 因为被存储的元素集合实现了Comparavle接口，SUN编写了TreeSet集合在添加元素的时候，
                  * 会调用compareTo方法进行比较，在包装类型中都已实现了Comparavle但是在自定义对象中
                  * 如果未实现Comparavle接口的方法，会在Comparable<? super K> k = (Comparable<?
                  *  super K>) key;强转失败从而报错。
                  */
             }
             //
         }
     }
     class Student5 implements Comparable {
         int age;
     
         public Student5(int age) {
             this.age = age;
         }
     
         // 实现Comparable接口中的方法
         public int compareTo(Object o) {
             int age1 = this.age;
             int age2 = ((Student5)o).age;
             // 编写一个比较规则
             return age1 - age2;
         }
     
         @Override
         public String toString() {
             return "Student5{" +
                     "age=" + age +
                     '}';
         }
     }
     

   • 示例代码02：

     /**
      * 总结自动排序：
      * 自动排序实现的原理：
      * 当TreeSet集合添加元素时，如果元素不重复则自动会排序，在TreeSet内部强转成Comparator
      * 自动调用compareTo方法或在创建集合比较器进行排序.
      * 注：当自定义创建对象时候，使用TreeSet或其他自动排序集合时候需要实现以上两种的任意一种方法，以实现自动排序
      * 1.实现类直接实现Comparable接口并实现compareTo方法：缺点：一旦实现Comparable不再是原来的类
      * 2.直接创建一个类在这个类种实现Comparator接口中compare方法，然后在创建TreeSet或其他自动排序集合时
      * 将参数直接创建该类对象即可.此方法可以实现代码的复用，值得推荐！
      */
     public class SortedSetTest03 {
         public static void main(String[] args) {
             // 创建集合
             SortedSet so = new TreeSet(new Compare());
             // 添加元素
             Shoe s1 = new Shoe(12.9);
             Shoe s2 = new Shoe(14.9);
             Shoe s3 = new Shoe(1.9);
             Shoe s4 = new Shoe(1.0);
             so.add(s1);
             so.add(s2);
             so.add(s3);
             so.add(s4);
             // 遍历
             Iterator i = so.iterator();
             while (i.hasNext()) {
                 System.out.println(i.next());
             }
         }
     }
     class Shoe {
         double price;
     
         public Shoe(double price) {
             this.price = price;
         }
     
         @Override
         public String toString() {
             return "Shoe{" +
                     "price=" + price +
                     '}';
         }
     }
     class Compare implements Comparator {
         public int compare(Object o1,Object o2) {
             double price1 = ((Shoe)o1).price;
             double price2 = ((Shoe)o2).price;
             if (price1==price2) {
                 return 0;
             }else if (price1>price2) {
                 return 1;
             }else {
                 return -1;
             }
         }
     }