Collections.reverseOrder())是返回一个强制反转的比较器。它具有2种形态，有参(自定义comparator)和无参（默认comparator）的。
--------------------------------------------------------------------------------------------------------------
21天的练习题代码：

从104行开始：
Comparator<Student> cmp = Collections.reverseOrder();
Set<Student> stus = StuTool.StuToolRead(cmp);

这两句为什么不能写成：
Set<Student> stus = StuTool.StuToolRead(Collections.reverseOrder());

我试了下写成这种他要报错：

C:\Documents and Settings\Administrator\桌面\BH-temp>javac fx.java
fx.java:122: 找不到符号
符号： 方法 StuToolRead(java.util.Comparator<java.lang.Object>)
位置： 类 StuTool
                Set<Student> stus = StuTool.StuToolRead(Collections.reverseOrder());
                                           ^
Code:

1. 
   
2. *import java.io.*;
   
3. import java.util.*;
   
4. 
   
5. class Student implements Comparable<Student>
   
6. {
   
7. private String name;
   
8. private int en,cn,ma,sum;
   
9. 
   
10. public int compareTo(Student s)
    
11. {
    
12. int num = new Integer(this.sum).compareTo(new Integer(s.sum));
    
13. 
    
14. if(num == 0)
    
15. return this.name.compareTo(s.name);
    
16. 
    
17. return num;
    
18. }
    
19. 
    
20. public int hashCode()//err
    
21. {
    
22. return name.hashCode()+sum*34;
    
23. }
    
24. 
    
25. public boolean equals(Object obj)
    
26. {
    
27. if(!(obj instanceof Student))
    
28. throw new ClassCastException("不是学生类");
    
29. 
    
30. Student s = (Student)obj;
    
31. return this.name.equals(s.name) && this.sum == s.sum;
    
32. }
    
33. 
    
34. Student(String name,int en,int cn,int ma)
    
35. {
    
36. this.name = name;
    
37. this.en = en;
    
38. this.cn = cn;
    
39. this.ma = ma;
    
40. sum = en+cn+ma;
    
41. }
    
42. 
    
43. public String toString()
    
44. {
    
45. return "name= "+name+",en= "+en+",cn= "+cn+",ma= "+ma+";"+"\t"+"sum="+sum;
    
46. }
    
47. }
    
48. 
    
49. class StuTool //定义该类是为了操作学生类
    
50. {
    
51. public static Set<Student> StuToolRead() throws IOException
    
52. {
    
53. return StuToolRead(null);
    
54. }
    
55. 
    
56. public static Set<Student> StuToolRead(Comparator<Student> cmp) throws IOException
    
57. {
    
58. /*IO操作,输入，存入*/
    
59. 
    
60. //建容器存学生
    
61. TreeSet<Student> ts = null;
    
62. 
    
63. if(cmp==null)
    
64. ts = new TreeSet<Student>();
    
65. else
    
66. ts = new TreeSet<Student>(cmp);
    
67. 
    
68. 
    
69. String s =null; //读写
    
70. BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//读:键盘获取字节,字节->字符。
    
71. 
    
72. while((s= br.readLine())!=null)//读
    
73. {
    
74. if(s.equals("over")) //结束标记
    
75. break;
    
76. 
    
77. String [] str = s.split(",");//切割
    
78. ts.add(new Student( str[0],Integer.parseInt(str[1]),//读一行，装一个学生到集合里去
    
79. Integer.parseInt(str[2]),
    
80. Integer.parseInt(str[3])));
    
81. 
    
82. }
    
83. br.close();
    
84. return ts;
    
85. }
    
86. 
    
87. public static void StuToolWrite(Set<Student> stus) throws IOException
    
88. {
    
89. BufferedWriter bw = new BufferedWriter(new FileWriter("StuInfo.txt"));//写:关联目的地
    
90. 
    
91. for (Student s : stus)
    
92. {
    
93. bw.write(s.toString());
    
94. bw.flush();
    
95. bw.newLine();
    
96. }
    
97. bw.close();
    
98. }
    
99. }
    
100. 
     
101. class Run
     
102. {
     
103. public static void main(String [] args) throws IOException
     
104. {
     
105. Comparator<Student> cmp = Collections.reverseOrder();
     
106. 
     
107. Set<Student> stus = StuTool.StuToolRead(cmp);
     
108. StuTool.StuToolWrite(stus);
     
109. }
     
110. }
     

复制代码

API:
reverseOrderpublic static <T> Comparator<T> reverseOrder()返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。（自然顺序是通过对象自身的 compareTo 方法强行排序的。）此方法允许使用单个语句，以逆自然顺序对实现了 Comparable 接口的对象 collection（或数组）进行排序（或维护）。例如，假设 a 是一个字符串数组。那么：                Arrays.sort(a, Collections.reverseOrder());将按照逆字典（字母）顺序对数组进行排序。 返回的比较器是可序列化的。
返回： 返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

怎么不可,完全可以

1. public static void main(String [] args) {
   
2. 
   
3. //不加比较器打印1,3,5,逆转之后打印5,3,1
   
4.                 TreeSet<Integer> list = new TreeSet<Integer>(Collections.reverseOrder());
   
5.                 list.add(3);
   
6.                 list.add(5);
   
7.                 list.add(1);
   
8.                
   
9.                 for(Integer i : list) {
   
10.                         System.out.println(i);
    
11.                 }
    
12.         }

复制代码

孙胜 发表于 2013-4-27 22:27
怎么不可,完全可以

这样写是可以  我在考虑我发的代码该如何写成一句啊？ 它是通过函数传递的反转比较器  这样传递，泛型该怎么定义是个问题啊  结合上下文来看  我还真没想出该怎么写。。。

HM朱蛟 发表于 2013-4-29 05:13
这样写是可以  我在考虑我发的代码该如何写成一句啊？ 它是通过函数传递的反转比较器  这样传递，泛型该 ...

他还有个重载的函数
Collections.reverseOder(cmp)传给集合的构造函数就OK了

孙胜 发表于 2013-4-29 08:00
他还有个重载的函数
Collections.reverseOder(cmp)传给集合的构造函数就OK了

哥们儿你说的这个有参数的Collections.reverseOder(cmp) ，这个是专门处理自定义比较器反转的啊。 和我发的代码有啥联系呢？{:soso_e132:}