compareto()怎么凭借两个数的返回值就获取到一组数据的大小顺序了呢？

如果有两个数 3和5 和9比较，都是比5小，都是返回-1，返回同样的数要再重复比较吗？我看毕老师写的TreeSet自定义比较比较对象中代码也没有循环语句，怎么结果就像是循环对比了一样呢？

public class TreeSetDemo2  
{
    public static void main(String[] args)  
    {
        TreeSet<Student> ts = new TreeSet<Student>();

        ts.add(new Student("lisi0",30));
        ts.add(new Student("lisi0",30));
        ts.add(new Student("lisi0",36));
        ts.add(new Student("lisi0",23));
        ts.add(new Student("lisi0",37));
        ts.add(new Student("lisi0",98));

        System.out.println(ts);
        //由打印结果可知，只存入了一个年龄30的学生。因为根据年龄相同的原则来判等。
        //你在存入数据是，就会根据你的compareTo方法来判等，判等则不能够再次存入。
        //比较过程是java自己封装的，无须我们开发者关心。
        
        
    }
}

//为了简单说明，我只比较了年龄。
class Student implements Comparable<Object>
{
    int age;
    String name;
    Student(String name,int age)
    {
        this.age = age;
        this.name = name;
    }

    public int compareTo(Object obj)
    {
        if(obj instanceof Student)
        {
            Student stu = (Student)obj;
            if(this.age>stu.age)
                return 1;
            if(this.age==stu.age)
                return 0;
            return -1;
        }
        
        else
        {
                throw new RuntimeException("请放入学生对象!");
        }
        
      
    }
    public  String toString()
    {
            return this.name+":"+this.age;
    }
   
   
}

1. public V put(K key, V value) {
   
2.         Entry<K,V> t = root;
   
3.         if (t == null) {
   
4.             // TBD:
   
5.             // 5045147: (coll) Adding null to an empty TreeSet should
   
6.             // throw NullPointerException
   
7.             //
   
8.             // compare(key, key); // type check
   
9.             root = new Entry<K,V>(key, value, null);
   
10.             size = 1;
    
11.             modCount++;
    
12.             return null;
    
13.         }
    
14.         int cmp;
    
15.         Entry<K,V> parent;
    
16.         // split comparator and comparable paths
    
17.         Comparator<? super K> cpr = comparator;
    
18.         if (cpr != null) {
    
19.             do {
    
20.                 parent = t;
    
21.                 cmp = cpr.compare(key, t.key);
    
22.                 if (cmp < 0)
    
23.                     t = t.left;
    
24.                 else if (cmp > 0)
    
25.                     t = t.right;
    
26.                 else
    
27.                     return t.setValue(value);
    
28.             } while (t != null);
    
29.         }
    
30.         else {
    
31.             if (key == null)
    
32.                 throw new NullPointerException();
    
33.             Comparable<? super K> k = (Comparable<? super K>) key;
    
34.             do {
    
35.                 parent = t;
    
36.                 cmp = k.compareTo(t.key);
    
37.                 if (cmp < 0)
    
38.                     t = t.left;
    
39.                 else if (cmp > 0)
    
40.                     t = t.right;
    
41.                 else
    
42.                     return t.setValue(value);
    
43.             } while (t != null);
    
44.         }
    
45.         Entry<K,V> e = new Entry<K,V>(key, value, parent);
    
46.         if (cmp < 0)
    
47.             parent.left = e;
    
48.         else
    
49.             parent.right = e;
    
50.         fixAfterInsertion(e);
    
51.         size++;
    
52.         modCount++;
    
53.         return null;
    
54.     }

复制代码

这个是TreeMap集合的put方法，在set底层其实就是由Map集合来实现的，循环的不是compareTo方法，而是put方法，在put方法中
循环调用了compareTo方法，所以造成了循环的结果，循环是为了判断每一个元素与新添加元素之间的关系，避免重复同时进行排序