类 TreeSet<E> 遍历 TreeSet<String> 和TreeSet<Person>

类TreeSet <E>  a.基于 TreeMap 的 NavigableSet 实现。

                             b.使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。

                             c. 遍历方式:  iterator  toArray

                            d.此类实现不是同步,所以不安全

/** TreeSet 两种遍历方式

      treeSet<Sting>和treeset<Person> 的区别

     treeSet<String> ,String引用类型是官方定义的,所有它可以应用treeSet的所有方法.

     treeSet<Person> ,Person类型时通过add()增加元素时,需要根据创建Set提供的Comparator进行排序,具体需要通过重写person类里的compareTo()方法*/

TreeSet<String> t=new TreeSet<String>();
            //add(E e)将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
              
            t.add("aello");
            t.add("Morld");
            t.add("Hello");
            t.add("I");
            Object[] ob=t.toArray();

           //遍历

              for(int i=0;i<ob.length;i++){
                Object obj=ob[i];
                String str=(String) obj;
                System.out.print(str+" ");
            }

            //另一遍历方式

       Iterator io=t.iterator();
              while(io.hasNext()){
                  System.out.print(io.next()+" ");
              }
            System.out.println();
            System.out.println("=====================================2");

             TreeSet<Person> tr=new TreeSet<Person>();
                Person t1=new Person("张三",19);
                Person t2=new Person("张三",19);
                Person t3=new Person("张三",18);
                Person t4=new Person("张三",17);
                Person t5=new Person("李四",19);
                Person t6=new Person("AA",14);
                tr.add(t1);
                tr.add(t2);
                tr.add(t3);
                tr.add(t4);
                tr.add(t5);
                tr.add(t6);
                //遍历
                Object[] obje=tr.toArray();
                for(int i=0;i<obje.length;i++){
                    Object objec=obje[i];
                    Person str1=(Person) objec;
                    System.out.print(str1+" ");
                }
                System.out.println();
                System.out.println("=======================1");    
                //另一遍历方式
                Iterator ioe=tr.iterator();
                        while(ioe.hasNext()){
                            System.out.println(ioe.next());
                        }
                System.out.println("=======================2");    
                
            }
}

//Person类型时通过add()增加元素时,需要根据创建Set提供的Comparator进行排序,具体需要通过重写person类里的compareTo()方法*/

public class Person implements Comparable{
                
                String name;
                int age;
                public Person(){
                
                }
                public Person(String name,int age){
                            this.name=name;
                            this.age=age;            
                    
                }
                public void setName(String name){
                    this.name=name;
                    
                }
                public String getName(){
                    return this.name;
                }
                public void setAge(int age){
                    this.age=age;
                    
        }
                public int getAge(){
                    return this.age;
                }
                public String toString(){
                    return "名字:"+this.name+" 年龄:"+this.age;
                }
                //排序
                public int compareTo(Object p){
                            int i=0;
                            if(p instanceof Person){
                                  Person p1=(Person) p;
                                  if(this.age<p1.age){
                                          return i=this.age-p1.age;
                                  }else if(this.age>p1.age){
                                              return i=this.age-p1.age;
                                          }
                                   else if(this.name.compareTo(p1.name)>0){
                                               return 1;
                                  }else {if(this.name.compareTo(p1.name)<0){
                                               return -1;
                                           }
                                  }
                                      
                            
                                  }
                                 
                    
                            return i;
                            
                            
                    
                }
               
}