情景如下：TreeSet<Point<String>> spSet = new TreeSet<Point<String>>();
如何才能实现自然排序，是不是需要这个Point类实现Comparable接口，但是现在这个Point是带泛型的，其声明如下：
class Point<T>{ --- }  ;
如果这样声明：class Point<T> implements Comparable<T> { --- }，那么类中重写的compareTo方法如何实现呢？

有没有大神帮帮忙啊！！！！！！！！！！！

我自己尝试实现了，但是很别扭，感觉不通常，有没有人交流下

1. package blog9;
   
2. 
   
3. import java.util.TreeSet;
   
4. 
   
5. /**
   
6. * 泛型使用实例:
   
7. * 1、定义一个表示点的类，包含横坐标和纵坐标值，且值具有三种形式，string、Integer、double。
   
8. * 2、通过实现带泛型的comparable接口排序
   
9. * 难题：如何让Point<T>实现comparable<T>接口，因为这里带了泛型，那么TreeSet的自然排序如何实现
   
10. */
    
11. public class TestGeneric {
    
12. 
    
13.         public static void main(String[] args) {
    
14.                 //坐标为String类型
    
15.                 TreeSet<Point<String>> spSet = new TreeSet<Point<String>>();
    
16.                 spSet.add(new Point<String>("10","20"));
    
17.                 spSet.add(new Point<String>("5","30"));
    
18.                 spSet.add(new Point<String>("100","20"));
    
19.                 System.out.println(spSet);
    
20.                 //输出：[Point [x=5, y=30], Point [x=10, y=20], Point [x=100, y=20]]
    
21.                
    
22.                 TreeSet<Point<Integer>> ipSet = new TreeSet<Point<Integer>>();
    
23.                 ipSet.add(new Point<Integer>(40,60));
    
24.                 ipSet.add(new Point<Integer>(20,60));
    
25.                 ipSet.add(new Point<Integer>(330,60));
    
26.                 ipSet.add(new Point<Integer>(5,60));
    
27.                 System.out.println(ipSet);
    
28.                 //输出：[Point [x=5, y=60], Point [x=20, y=60], Point [x=40, y=60], Point [x=330, y=60]]
    
29.                
    
30.                 TreeSet<Point<Double>> dpSet = new TreeSet<Point<Double>>();
    
31.                 dpSet.add(new Point<Double>(5.5,62.1));
    
32.                 dpSet.add(new Point<Double>(200.5,30.54));
    
33.                 dpSet.add(new Point<Double>(0.7,6.0));
    
34.                 dpSet.add(new Point<Double>(500.54,20.4));
    
35.                 System.out.println(dpSet); //这里是以y升序的，在compareTo方法中实现
    
36.                 //[Point [x=0.7, y=6.0], Point [x=500.54, y=20.4], Point [x=200.5, y=30.54], Point [x=5.5, y=62.1]]
    
37. 
    
38.         }
    
39. }
    
40. 
    
41. class Point<T> implements Comparable<Point<T>>{
    
42. 
    
43.         private T x;
    
44.         private T y;
    
45.        
    
46.         public Point(T x,T y) {
    
47.                 this.x = x;
    
48.                 this.y = y;
    
49.         }
    
50.        
    
51.         @Override
    
52.         public String toString() {
    
53.                 return "Point [x=" + x + ", y=" + y + "]";
    
54.         }
    
55. 
    
56.         @Override
    
57.         public int hashCode() {
    
58.                 final int prime = 31;
    
59.                 int result = 1;
    
60.                 result = prime * result + ((x == null) ? 0 : x.hashCode());
    
61.                 result = prime * result + ((y == null) ? 0 : y.hashCode());
    
62.                 return result;
    
63.         }
    
64. 
    
65.         @SuppressWarnings("rawtypes")
    
66.         @Override
    
67.         public boolean equals(Object obj) {
    
68.                 if (this == obj)
    
69.                         return true;
    
70.                 if (obj == null)
    
71.                         return false;
    
72.                 if (getClass() != obj.getClass())
    
73.                         return false;
    
74.                 Point other = (Point) obj;
    
75.                 if (x == null) {
    
76.                         if (other.x != null)
    
77.                                 return false;
    
78.                 } else if (!x.equals(other.x))
    
79.                         return false;
    
80.                 if (y == null) {
    
81.                         if (other.y != null)
    
82.                                 return false;
    
83.                 } else if (!y.equals(other.y))
    
84.                         return false;
    
85.                 return true;
    
86.         }
    
87. 
    
88.         @Override
    
89.         public int compareTo(Point<T> o) {
    
90.                 if(o.x instanceof String){
    
91.                         String s = (String)this.x;
    
92.                         return Integer.parseInt(s) - Integer.parseInt((String)o.x);
    
93.                         //感觉好麻烦，两个强转，失去了泛型的意义了
    
94.                 }
    
95.                 if(o.x instanceof Integer){
    
96.                         Integer i = (Integer)this.x;
    
97.                         return i.compareTo((Integer)o.x);
    
98.                 }
    
99.                 if(o.x instanceof Double){//当Point的类型为double时，用y值排序
    
100.                         Double d = (Double)this.y;
     
101.                         return d.compareTo((Double)o.y);
     
102.                 }
     
103.                 return 0;
     
104.         }
     
105. }

复制代码

哎妈呀，半天没人鸟，来个人啊，咱们讨论学术呗

你的比较方法中的元素是泛型的，自己的不知道是什么，那么怎么比较呢？
我认为有两个方法解决，一个是建立比较器comparator，根据确定类型后在判定

另一个是在构造方法中添加一个元素
public Point(T x,T y，String comparaName) {
                this.x = x;
                this.y = y;
                 this.comparaName=comparaName;
        }
也就是说构造方法时此成员变量只做为comparable方法中的比较元素使用。
上面的两种方法应该没有问题吧？我也是看到你的题目后才想到的。

来自沙沙的我 发表于 2014-6-19 16:48
你的比较方法中的元素是泛型的，自己的不知道是什么，那么怎么比较呢？
我认为有两个方法解决，一个是建立 ...

题主意思可能是 三种Point参数类型 都要写出比较方法
其中String类的方法比较麻烦 要强转 如何简写或者统一？

point的String类参数，要按照阿拉伯数字排序 我觉得只能用parseInt了吧。。
这三者（尤其String）想通过一个compareTo泛到一起去 恐怕不能更简便

HF_Opticalix 发表于 2014-6-19 17:08
题主意思可能是 三种Point参数类型 都要写出比较方法
其中String类的方法比较麻烦 要强转 如何简写或者统 ...

恩，刚刚没有看到后面还有题目，那么这样应该可以吧

class Point implements Comparable<Point>{

    private Integer x;
    private Integer y;
    private String a;
    private String b;
    private Double i;
    private Double j;

   
     Point(Integer x,Integer y) {
            this.x = x;
            this.y = y;
    }
     Point(String a,String b) {
        this.a = a;
        this.b = b;
    }
     Point(Double i,Double j) {
        this.i = i;
        this.j = j;
    }
}

直接定义6个成员变量，三个构造方法
那么comparable的比较方法就不用进行强转了。

来自沙沙的我 发表于 2014-6-19 17:41
恩，刚刚没有看到后面还有题目，那么这样应该可以吧

class Point implements Comparable{

这样Point就不带泛型了，支持一下 看楼主怎么说

HF_Opticalix 发表于 2014-6-19 18:06
这样Point就不带泛型了，支持一下 看楼主怎么说

这位同学，我刚刚写的东西你看到了？我自己怎么没有看到呢。被删了？

HF_Opticalix 发表于 2014-6-19 18:06
这样Point就不带泛型了，支持一下 看楼主怎么说

没事了，原来刚写的东西跑前面去了，论坛的规矩搞不懂。。。

来自沙沙的我 发表于 2014-6-19 18:11
没事了，原来刚写的东西跑前面去了，论坛的规矩搞不懂。。。

{:3_59:}{:3_59:}额

来自沙沙的我 发表于 2014-6-19 17:41
恩，刚刚没有看到后面还有题目，那么这样应该可以吧

class Point implements Comparable{

Point也需要是带泛型的啊

来自沙沙的我 发表于 2014-6-19 18:10
这位同学，我刚刚写的东西你看到了？我自己怎么没有看到呢。被删了？

还是没有找到特别精巧的办法，让Point带泛型，同时实现comparable接口，comparable接口带嵌套泛型

不知道是不是没有合适答案也必须结贴啊，或者，来个大神指教下