适用于可比较和比较器的泛型

Question

基本上，我有一个通用BST，我想为Comparable对象和对象使用关联的Comparator类。例如，我希望该树可以与Integers一起使用，也可以用于Point2D，其中点可以按X方向或Y方向排序（为此我有相应的比较器）。我想知道做这个的标准方法是什么？我想出了这个：

public class Test <Data> { 
    public <Data extends Comparable> Test() { 
     System.out.println("Comparable"); 
     this.c = null; 
    } 

    public Test(Comparator<Data> comparator) { 
     System.out.println("Comparator"); 
     this.c = comparator; 
    } 

    public int compare(Data d1, Data d2) { 
     if (c == null) { 
      return ((Comparable)d1).compareTo(d2); 
     } else { 
      return this.c.compare(d1,d2); 
     } 
    }  

    Comparator<Data> c; 

    public static void main(String[] args) { 
     Test<Integer> test = new Test<Integer>(); 
     System.out.println(test.compare(1,2)); 

     Test<Point2D> test2 = new Test<Point2D>(Point2DCompare.Comparators.X); 
     System.out.println(test2.compare(new Point2D.Double(1,2),new Point2D.Double(2,2))); 
    }  
} 

其中Point2DCompare.Comparators.X是，通过他们的X坐标点排序一个简单的比较。这似乎工作，但它有点难看。我想知道是否有标准的方法来解决这个问题？

编辑：实现基于user1676075：

public class Test <Data> { 
    public <Data extends Comparable> Test() { 
     dataComparator = new Comparator<Data>() { 
      @Override 
      public int compare(Data p1,Data p2) { 
       return p1.compareTo(p2); 
      } 
     }; 
    } 

    public Test(Comparator<Data> comparator) { 
     dataComparator = comparator; 
    } 

    public final Comparator dataComparator; 

    public static void main(String[] args) { 
     Test<Integer> test = new Test<Integer>(); 
     System.out.println(test.dataComparator.compare(1,2)); 

     Test<Point2D> test2 = new Test<Point2D>(Point2DCompare.Comparators.X); 
     System.out.println(test2.dataComparator.compare(new Point2D.Double(1,2),new Point2D.Double(2,2))); 
    }  
} 

EDIT2：与第二个实施的一个问题是，它并不会导致编译错误，如果没有使用非可比Data比较。例如：

Test<Point2D> test3 = new Test<Point2D>(); 
System.out.println(test3.dataComparator.compare(new Point2D.Double(1,2),new Point2D.Double(2,2))); 

导致运行时错误。如果有一个完整的解决方案，这将是很好的。

Answer 1

唯一的类型安全的方法是使用静态工厂方法创建基于可比较的而不是构造函数的自然顺序的类。静态方法将是通用的，将只接受满足可比对自身的约束类型：

public class Test<Data> { 
    Comparator<Data> c; 

    public Test(Comparator<Data> comparator) { 
     System.out.println("Comparator"); 
     this.c = comparator; 
    } 

    public static <T extends Comparable<? super T>> Test<T> createWithComparable() { 
     System.out.println("Comparable"); 
     return new Test<T>(new Comparator<T>() { 
      @Override 
      public int compare(T p1,T p2) { 
       return p1.compareTo(p2); 
      } 
     }); 
    } 
} 

Answer 2

创建一个默认比较器。默认比较器的行为是查看并查看两个对象是否为Comparable。如果这样比较，如果没有，则抛出异常。将此比较器分配给您的类中的实例变量。

然后你有两个选择。或者用一个可选的比较器创建类（在这种情况下，您可以替换默认的），并且您的比较代码只使用分配给该实例变量的比较器，或者您的比较方法可选地使用比较器，并使用传入的比较器或您的如果没有传递，则为默认。使用哪种方法将取决于你的班级如何被调用。