黑马程序员技术交流社区

标题: Collections中最大值的问题 [打印本页]
作者: 罗广伟    时间: 2013-8-7 11:29
标题: Collections中最大值的问题
本帖最后由 杨兴庭 于 2013-8-7 17:57 编辑
  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吧
作者: 黑马龙子    时间: 2013-8-7 14:21
在这不管是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. }
复制代码
作者: 杨增坤    时间: 2013-8-7 14:47
在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
--------根据自然排序找最大值------

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

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





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2