版主很强悍啊，随便出道题我写了6个小时。
一共两个类    一个主类  一个Student类
主类有三个函数分别实现了 获取键盘录入的函数，录入的结果的函数，获取第三的版主及第四和第六的函数。
至于尾号依次为2、3、6的不允许出入的功能没有实现，我在考虑一下。
以下是此程序图片和打印结果
郑光宗进去了
刘凯进去了
王徐杰进去了
伍哲沂进去了
尹丽峰进去了
刘凯进去了
袁梦希进去了
袁梦希进去了
孙百鑫进去了
巩建进去了
王徐杰进去了
伍哲沂进去了
尹丽峰进去了
刘凯进去了
袁梦希进去了
袁梦希进去了
孙百鑫进去了
巩建进去了
王徐杰进去了
伍哲沂进去了
尹丽峰进去了
刘凯进去了
袁梦希进去了
袁梦希进去了
孙百鑫进去了
巩建进去了
王徐杰进去了
伍哲沂进去了
袁梦希进去了
袁梦希进去了
郑光宗进去了1次
袁梦希进去了8次
孙百鑫进去了3次
巩建进去了3次
王徐杰进去了4次
伍哲沂进去了4次
尹丽峰进去了3次
刘凯进去了4次
郑光宗次数排名第四
孙百鑫次数排名第三
巩建次数排名第三
尹丽峰次数排名第三

1. import java.io.*;
   
2. import java.util.*;
   
3. public class heimeTest {
   
4.         public static void main(String[] args) throws IOException {       
   
5.                 List<Student> list=inputStudent();        //调用获取键盘录入的函数
   
6.                 TreeMap tm=outputStudent(list);//输出录入的结果的函数
   
7.                 getluckSttudent(tm);//获取第三的版主及第四和第六的。
   
8.         }
   
9.         public static List inputStudent() throws IOException//获取键盘录入的函数
   
10.         {
    
11.                 String line;
    
12.                 Student stu=null;
    
13.                 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));//读取键盘录入
    
14.                 List<Student> list=new ArrayList<Student>();//创建ArrayList此处用了泛型
    
15.                 while((line=br.readLine())!=null)//利用循环读取键盘录入
    
16.                 {
    
17.                         if("over".equals(line))//结束标记over
    
18.                                 break;
    
19.                         String []s=line.split(" +");//切割字符串
    
20.                         stu=new Student(s[0].trim(),s[1].trim());//去除字符串两端空格
    
21.                         list.add(stu);//Student对象进入List表
    
22.                 }
    
23.                 return  list;//返回List
    
24.         }
    
25.         public static TreeMap outputStudent(List list)//输出录入的结果的函数
    
26.         {
    
27.                 final TreeMap<Student,Integer> tm=new TreeMap<Student,Integer>();//新建一个TreeMap集合此处用了泛型
    
28.                 int len=list.size();
    
29.                 for(int i=0;i<len;i++)//利用循环获取List中每个元素
    
30.                 {
    
31.                         Student s=(Student)list.remove(0);//弹出首元素
    
32.                         System.out.println(s.name+"进去了");
    
33.                         if(!(tm.containsKey(s)))//Student对象进入TreeMap
    
34.                                 tm.put(s,1);
    
35.                         else
    
36.                         {
    
37.                                 tm.put(s, tm.get(s)+1);
    
38.                         }               
    
39.                 }
    
40.                 for(Student s:tm.keySet())//高级For循环遍历TreeMap
    
41.                 {
    
42.                         System.out.println(s.name+"进去了"+tm.get(s)+"次");
    
43.                 }
    
44.                 return tm;
    
45.         }
    
46.         public static void getluckSttudent(TreeMap tm)//获取第三的版主及第四和第六的。
    
47.         {
    
48.                 Set s=new TreeSet();
    
49.                 Set<Student> set=tm.keySet();
    
50.                 for(Student stu:set)
    
51.                 {
    
52.                    s.add((Integer)tm.get(stu));
    
53.                 }
    
54.                 Object[] arr=s.toArray();//获取TreeMap中的值的集合并转成数组
    
55.                 Arrays.sort(arr);//对数组排序
    
56.                 for(Student stu:set)
    
57.                 {
    
58.                         if(arr.length>=3)//如果数组长度大于3输出第3名
    
59.                         {
    
60.                                 if((Integer)tm.get(stu)==arr[arr.length-3])
    
61.                                         System.out.println(stu.name+"次数排名第三");
    
62.                         }
    
63.                         if(arr.length>=4)//如果数组长度大于4输出第4名
    
64.                         {
    
65.                                 if((Integer)tm.get(stu)==arr[arr.length-4])
    
66.                                         System.out.println(stu.name+"次数排名第四");
    
67.                         }
    
68.                         if(arr.length>=6)//如果数组长度大于6输出第6名
    
69.                         {
    
70.                                 if((Integer)tm.get(stu)==arr[arr.length-6])
    
71.                                         System.out.println(stu.name+"次数排名第六");
    
72.                         }       
    
73.                 }
    
74.         }
    
75. }
    
76. class Student implements Comparable//创建Student类并实现排序的接口
    
77. {
    
78.         String name;
    
79.         String num;
    
80.         Student(String name,String num)//构造函数
    
81.         {
    
82.                 this.name=name;this.num=num;
    
83.         }
    
84.         public int hashCode()//复写hashCode
    
85.         {
    
86.                 return num.hashCode();
    
87.         }
    
88.         public boolean equals(Student p1)//复写equals
    
89.         {
    
90.                 //Person1 p=(Person1)obj;
    
91.                 return (this.name==p1.name)&&(this.num==p1.num);
    
92.         }
    
93.         public int compareTo(Object obj) {//复写compareTo
    
94.                 Student stu=(Student)obj;
    
95.                 return this.num.compareTo(stu.num);
    
96.         }
    
97. }

复制代码

来看看是什么题目。

今天忙了一天，就写这道程序了。发现学习和实际写代码就是不一样啊！学会一些知识很容易，但写代码的时候就是另一回事了！写代码要非常注意一些小细节，比如我在写代码是把name写成了nname,一个小错误硬是找了几十分钟！

多谢楼主

郭伟杰 发表于 2013-6-27 18:47

亲，你似乎发错地方了……专门有个答案贴，在这里发答案是木有分的哦~

先看下 瞅瞅

好的，让我来看看什么题型

看看
{:3_46:}

kan yi xia

看下题先:D

先看题，再说

什么时候截止？

看题哟哟哟哟

看下题目吧！

看一下什么题

我会认真完成的

看下题先

貌似很难的样子哦

第一题

1. package majun.jun;
   
2. 
   
3. import java.util.Map;
   
4. import java.util.Scanner;
   
5. import java.util.TreeMap;
   
6. import java.util.Map.Entry;
   
7. 
   
8. public class RoleOutStudent {
   
9. 
   
10.         /**
    
11.          * role 规则
    
12.          * out  输出
    
13.          * RoleOutStudent  规则输出学生类
    
14.          */
    
15.         public static void main(String[] args) {
    
16.                         StringBuilder sb = getStringBuilder();//键盘录入内容转换成 StringBulider
    
17.                         Student[] stu = toStudentArray(sb);//获取对象数组
    
18.                         roleOut(stu);//检查对象数组重复情况 value的值 即是对象出现的次数
    
19.         }
    
20.         private static Student[] toStudentArray(StringBuilder sb) {
    
21.                 String lines=new String(sb);
    
22.                 System.out.println(sb);
    
23.                 String[] str=lines.split("( )+");//用空格切割
    
24.                 Student[] stu=new Student[str.length/2];//观察题目知道 字符串数组是学生数组长度的2倍
    
25.                 int y=0;
    
26. //               
    
27.                 for(int x=0;x<str.length;x+=2){
    
28.                         stu[y]=new Student(str[x],str[x+1]);
    
29.                         y++;
    
30.                 }
    
31.                 return stu;
    
32.         }
    
33.         public static void roleOut(Student[] stu) {
    
34.                 Map<Student,Integer> map=new TreeMap<Student,Integer>();
    
35. //        对对象数组经行检查 发现重复对象 改变键值即可       
    
36.                 for(int x=0;x<stu.length;x++){
    
37.                         if(!map.containsKey(stu[x])){
    
38.                                 map.put(stu[x], 1);
    
39.                         }else{
    
40.                                 map.put(stu[x], map.get(stu[x])+1);
    
41.                         }
    
42.                 }
    
43. //                键的值即是学生对象出现的次数
    
44.                 for(Entry<Student,Integer> entry:map.entrySet()){
    
45.                         Student s=entry.getKey();
    
46.                         Integer value=entry.getValue();
    
47.                         s.setCount(value);
    
48.                         System.out.println(s);
    
49.                 }
    
50.         }
    
51.         private static StringBuilder getStringBuilder() {
    
52.                 Scanner scan=new Scanner(System.in);//控制台录入题目内容
    
53.                 StringBuilder sb=new StringBuilder();
    
54.                 String line=null;
    
55. //                观察题目 需要15行 故循环15次
    
56.                 for(int i=0;i<15;i++){
    
57.                         line=scan.nextLine();
    
58.                         sb.append(line+" ");
    
59.                 }
    
60.                 return sb;
    
61.         }
    
62. }
    
63. package majun.jun;
    
64. 
    
65. import java.util.Comparator;
    
66. 
    
67. public class Student implements Comparable<Student>{
    
68. 
    
69.         /**
    
70.          *
    
71.          */
    
72.         String name;
    
73.         String id;
    
74.         int count;
    
75.         private Object instansOf;
    
76.         Student(String name,String id){
    
77.                 this.name=name;
    
78.                 this.id=id;
    
79.         }
    
80.         public String getName() {
    
81.                 return name;
    
82.         }
    
83.         public void setName(String name) {
    
84.                 this.name = name;
    
85.         }
    
86.         public String getId() {
    
87.                 return id;
    
88.         }
    
89.         public void setId(String id) {
    
90.                 this.id = id;
    
91.         }
    
92.         public int getCount() {
    
93.                 return count;
    
94.         }
    
95.         public void setCount(int count) {
    
96.                 this.count = count;
    
97.         }
    
98.        
    
99.         public String toString(){
    
100.                 return "姓名："+this.name+"  学号："+this.id+"  次数"+this.count;
     
101.         }
     
102.         @Override
     
103.         public int compareTo(Student s) {
     
104.                 /*
     
105.                  * 有泛型就不需要判断
     
106.                  * if(!(s instanceof Student)){
     
107.                         throw new RuntimeException("类型不匹配！");
     
108.                         }*/
     
109.                
     
110.                 int num=new Integer(this.count).compareTo(new Integer(s.count));
     
111.                 if(num==0){
     
112.                         return s.id.compareTo(this.id);
     
113.                 }
     
114.                 return num;
     
115.         }
     
116.         @Override
     
117.         public int hashCode() {
     
118.                 return name.hashCode()+id.hashCode();
     
119.         }
     
120.         @Override
     
121.         public boolean equals(Object obj) {
     
122.                 if(!(obj instanceof Student)){
     
123.                         throw new ClassCastException("类型不匹配！");
     
124.                 }
     
125.                 Student s=(Student)obj;
     
126.                 //当name id  相等时 视为同一个对象
     
127.                 return this.name.equals(s.name) && this.id.equals(s.id);
     
128.         }
     
129.        
     
130. //        强制让学生类具有比较性， 当次数相同时比较 id的自然顺序
     
131. /*@Override
     
132. public int compare(Student o1, Student o2) {
     
133.        
     
134.         int num=new Integer(o1.count).compareTo(o2.count);
     
135.         if(num==0){
     
136.                 return o1.getId().compareTo(o2.getId());
     
137.         }
     
138.         return num;
     
139. }
     
140.         */
     
141. }

复制代码

还有点小毛病 我在看看