1. import java.util.*;
   
2. public class CollectionsDemo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 List<Stu>al=new ArrayList<Stu>();
   
7.                 al.add(new Stu("zhangsan"));
   
8.                 al.add(new Stu("lisi"));
   
9.                 al.add(new Stu("wangwu"));
   
10.                 al.add(new Stu("zhaoliu"));
    
11.                 sop(al.toString());
    
12.                 Collections.sort(al);//采用Stu类compareTo排序
    
13.                 //Collections.sort(al,new StuCom());//用比较器排序
    
14.                 sop(al.toString());
    
15.                 sop(Collections.max(al));
    
16.                 //sop(Collections.max(al,new StuCom()));
    
17.         }
    
18.         public static void sop(Object obj)
    
19.         {
    
20.                 System.out.println(obj);
    
21.         }
    
22.         
    
23. }
    
24. class Stu implements Comparable<Stu>
    
25. {
    
26.         private String name;
    
27.         public String getName() {
    
28.                 return name;
    
29.         }
    
30.         Stu(String name)
    
31.         {
    
32.                 this.name=name;
    
33.         }
    
34.         public int compareTo(Stu stu)
    
35.         {
    
36.                 return this.name.compareTo(stu.name);
    
37.         }
    
38.         public String toString()
    
39.         {
    
40.                 return name;
    
41.         }
    
42. }
    
43. class StuCom implements Comparator<Stu>
    
44. //如果定义了比较器，Stu可以不实现Comparable接口
    
45. {
    
46.         public int compare(Stu stu1,Stu stu2)
    
47.         {
    
48.                 return stu2.getName().compareTo(stu1.getName());
    
49.         }
    
50. }

复制代码

问题1：为什么不论我把Stu中compareTo返回值改为1或者-1，collections的最大值返回都是zhaoliu呢？他的比较应该是依赖Stu的compareTo吧

在这不管是return 1 还是 -1 都是 不改变其排序结果值的。因为虽然定义一个类实现Comparable接口，覆盖compare方法，并将该类对象作为参数传递给ArrayList集合的构造函数数，还是没有其改变的。比较是依赖Stu的compareTo的。这样思考的：

1. import java.util.*;
   
2. public class CollectionsDemo
   
3. {
   
4.          public static void sop(Object obj)
   
5.      {
   
6.              System.out.println(obj);
   
7.      }
   
8.      public static void main(String[] args)
   
9.      {
   
10.              List<Stu>al=new ArrayList<Stu>();
    
11.          al.add(new Stu("zhangsan"));
    
12.          al.add(new Stu("lisi"));
    
13.          al.add(new Stu("wangwu"));
    
14.          al.add(new Stu("sxl"));
    
15.          sop("排序前："+al.toString());
    
16.          Collections.sort(al);//采用Stu类compareTo排序
    
17.          sop("排序后："+al.toString());
    
18.          sop("最大值："+Collections.max(al));  
    
19.         }
    
20. }
    
21. class Stu implements Comparable<Stu>
    
22. {//定义一个类实现Comparable接口，覆盖compare方法。
    
23.         private String name;
    
24.         public String getName() {
    
25.                 return name;
    
26.         }
    
27.         Stu(String name)
    
28.         {
    
29.                 this.name=name;
    
30.         }
    
31.         public int compareTo(Stu stu)
    
32.         {
    
33.                 return this.name.compareTo(stu.name);
    
34.         }
    
35.         public String toString()
    
36.         {
    
37.                 return name;
    
38.         }
    
39.       //定义一个比较器，让学生具备一个默认的比较性
    
40.    public int compare(Stu stu1,Stu stu2)
    
41.         {//覆盖compare()方法。
    
42.                            Stu s1 = (Stu)stu1;
    
43.                            Stu s2 = (Stu)stu2;
    
44.                         int num = s2.getName().compareTo(s1.getName());
    
45.                         if(num==0)
    
46.                         {
    
47.                                 return new Integer(s1.getName()).compareTo(new Integer(s2.getName()));
    
48.                         }
    
49.                         return num;
    
50.         }
    
51. }

复制代码

在CompareTo（）方法中增加输出语句
public int compareTo(Stu stu) {       
                System.out.println(this.name+"------"+stu.name);
                return this.name.compareTo(stu.name);
        }

public static void main(String[] args) {
                List<Stu> al = new ArrayList<Stu>();
                al.add(new Stu("zhangsan"));
                al.add(new Stu("lisi"));
                al.add(new Stu("wangwu"));
                al.add(new Stu("zhaoliu"));       
                sop(al.toString());
                System.out.println("--------排序------");
                Collections.sort(al);// 采用Stu类compareTo排序
                System.out.println("--------排序------");               
                sop(al.toString());
                System.out.println("--------根据自然排序找最大值------");               
                sop(Collections.max(al));
                System.out.println("--------根据自然排序找最大值------");               
        }

自然情况下结果：
[zhangsan, lisi, wangwu, zhaoliu]
--------排序------
lisi------zhangsan
wangwu------lisi
wangwu------zhangsan
wangwu------lisi
zhaoliu------wangwu
zhaoliu------zhangsan
--------排序------
[lisi, wangwu, zhangsan, zhaoliu]
--------根据自然排序找最大值------
wangwu------lisi
zhangsan------wangwu
zhaoliu------zhangsan
zhaoliu
--------根据自然排序找最大值------

根据结果我总结出排序的时候是进行的是二分查找然后进行的比较
结果总结：当查找最大值的时候，都是与最大值比较
compareTo的返回结果永远是1的时候：
[zhangsan, lisi, wangwu, zhaoliu]
--------排序------
lisi------zhangsan
wangwu------lisi
zhaoliu------wangwu
--------排序------
[zhangsan, lisi, wangwu, zhaoliu]
--------根据自然排序找最大值------
lisi------zhangsan
wangwu------lisi
zhaoliu------wangwu
zhaoliu
--------根据自然排序找最大值------

结果总结：当查找最大值的时候，都是与最大值比较

compareTo的返回结果永远是-1的时候：
[zhangsan, lisi, wangwu, zhaoliu]
--------排序------
lisi------zhangsan
wangwu------lisi
zhaoliu------wangwu
--------排序------
[zhaoliu, wangwu, lisi, zhangsan]
--------根据自然排序找最大值------
wangwu------zhaoliu
lisi------zhaoliu
zhangsan------zhaoliu
zhaoliu
--------根据自然排序找最大值------

结果总结：当查找最大值的时候，却都是与最小值比较

根据所有结果总结却找不到合理的解释，我感觉是不是根据的是比较的结果，然后才找最大值，而不是排序后的集合最后的元素才是最大的
希望对你有帮助！