谁帮我看看这个集合为什么第一个存进去的值是null呢，当我存的是两个元素的时候就不是null,结果就对的，当我存超过三个的时候有的就是存不了进去，键存进去了，值部分没存进去，结果是null,所以说Student这个类就每什么问题了，也不知道是不是JDK1.8的问题还是什么，谁帮帮看看这个代码吧，谢谢了！

1. import java.util.Comparator;
   
2. import java.util.HashMap;
   
3. import java.util.Iterator;
   
4. import java.util.Map;
   
5. import java.util.Map.Entry;
   
6. import java.util.Set;
   
7. import java.util.TreeMap;
   
8. import java.util.TreeSet;
   
9. 
   
10. class Test {
    
11.         public static void main(String[] agrs) {
    
12.                 TreeMap<Student,String> room2=new TreeMap<Student, String>();
    
13.                 room2.put(new Student("赵六",26),"广东");
    
14.                 room2.put(new Student("李四",20),"广西");
    
15.                  room2.put(new Student("王五",24),"广州");
    
16.                 room2.put(new Student("黄五",23),"上海");
    
17.                 room2.put(new Student("曾七",21),"北京");
    
18.                 room2.put(new Student("曾七",20),"北京");
    
19.                 get(room2);
    
20.         }
    
21. 
    
22.         public static void get(TreeMap t){//获取集合元素，打印方法
    
23.                 Set s=t.keySet();
    
24.                 Iterator it=s.iterator();
    
25.                 while(it.hasNext()){
    
26.                         Student key=(Student)it.next();
    
27.                         String value=(String)t.get(key);
    
28.                         System.out.println(key.name+":"+key.age+"="+value);
    
29.                 }
    
30.         }
    
31.        
    
32. }
    
33. class Student implements Comparable{//学生类
    
34.         String name;
    
35.         int age;
    
36.         Student(String name,int age){
    
37.                 this.name=name;
    
38.                 this.age=age;
    
39.         }
    
40.         public int compareTo(Object obj){
    
41.                 //System.out.println("zhi");
    
42.                 if (!(obj instanceof Student)) {
    
43.                         throw new RuntimeException("类型错误");
    
44.                 }
    
45.                 Student std=(Student)obj;
    
46.                 int nub=this.name.compareTo(std.name);
    
47.                 if (nub==0) {
    
48.                         return new Integer(this.age).compareTo(std.age);
    
49.                 }
    
50.                         return 1;
    
51.         }
    
52. }

复制代码

你帮运行一下，告诉一下我结果？

解释不通，等大神吧，只知道吧返回值改成nub没问题，为什么一面排会出现null也醉了

:)看下最后一句的返回值。我感觉问题在那里

学习一下

学生类的，返回值应该是nub  不是 ，  还是就是 集合加了泛型，你的Iterator 也要泛型  Set也必须要泛型  不然是不安全的，  泛型可以避免强转

       稍微Debug分析了一下子，其实存放的时候没有任何问题， 都存放到TreeMap中去了，但是在遍历的时候，发现出现了问题。因遍历的过程算法被
封装了，看不到。所以不知道他查找算法是怎么写的，但从我debug来看，个人认为也许其查找算法有瑕疵，考虑的不特别全面，导致特殊树型结构可能
没有被处理好。
       目前暂时认为修改就是：compare函数中不要强制访问一个值，搞个极端的树，这个写法其实你根本就没有做什么排序处理。

1. public int compareTo(Object obj){
   
2.                 //System.out.println("zhi");
   
3.                 if (!(obj instanceof Student)) {
   
4.                         throw new RuntimeException("类型错误");
   
5.                 }
   
6.                 Student std=(Student)obj;
   
7.                 int nub=this.name.compareTo(std.name);
   
8.                 if (nub==0) {
   
9.                         return new Integer(this.age).compareTo(std.age);
   
10.                 }
    
11.                         return 1;  --》<b>return nub</b>
    
12.         }

复制代码

问你个问题啊，你为什么要实现comparable呢，是为了使元素具备比较性么？那你的目的如果是这个，为什么要固定返回1？返回nub不好么

1. package Test3;
   
2. import java.util.Iterator;
   
3. import java.util.Set;
   
4. import java.util.TreeMap;
   
5. 
   
6. public class Deno1111 {
   
7.         public static void main(String[] agrs) {
   
8.                 TreeMap<Student,String> room2=new TreeMap<Student, String>();
   
9.                /* room2.put(new Student("赵六",26),"广东");
   
10.                 room2.put(new Student("李四",20),"广西");
    
11.                 room2.put(new Student("王五",24),"广州");
    
12.                 room2.put(new Student("黄五",23),"上海");
    
13.                 room2.put(new Student("曾七",21),"北京");
    
14.                 room2.put(new Student("曾七",20),"北京"); */
    
15.                 room2.put(new Student("1",26),"广东");
    
16.                 room2.put(new Student("2",20),"广西");
    
17.                 room2.put(new Student("3",24),"广州");
    
18.                 room2.put(new Student("4",23),"上海");
    
19.                 room2.put(new Student("5",21),"北京");
    
20.                 room2.put(new Student("5",20),"北京");
    
21.                
    
22.                 get(room2);
    
23.         }
    
24. 
    
25.         public static void get(TreeMap<Student,String>  t){//获取集合元素，打印方法
    
26.                 Set<Student> s=t.keySet();
    
27.                 Iterator<Student> it=s.iterator();
    
28.                 while(it.hasNext()){
    
29.                         Student key=(Student)it.next();
    
30.                         String value=(String)t.get(key);
    
31.                         System.out.println(key.name+":"+key.age+"="+value);
    
32.                 }
    
33.         }
    
34.         
    
35. }
    
36. class Student implements Comparable<Student>
    
37. {//学生类
    
38.         String name;
    
39.         int age;
    
40.         Student(String name,int age){
    
41.                 this.name=name;
    
42.                 this.age=age;
    
43.         }
    
44.         @Override
    
45.                 public int compareTo(Student obj) {
    
46.                         // TODO Auto-generated method stub
    
47.                          if (!(obj instanceof Student)) {
    
48.                  throw new RuntimeException("类型错误");
    
49.          }
    
50.          Student std=(Student)obj;
    
51.          int nub=this.name.compareTo(std.name);
    
52.          return nub==0?new Integer(this.age).compareTo(std.age):nub;
    
53.         
    
54.                 }
    
55. }

复制代码

你这样试试就知道哪错了 ？ 你的比较方法怎么看着都别扭

都好厉害啊