Java 可比<；类型>；阵列与可比阵列_Java_Arrays_Generics

Java 可比<；类型>；阵列与可比阵列

java arrays generics

Java 可比<；类型>；阵列与可比阵列,java,arrays,generics,Java,Arrays,Generics,我有一个点类，它实现了可比。我想做点f=arr[first] 现在，我读到使用原始类型Comparableetc是不好的。因此，如果我将arr[]类型设置为Comparable[]而不是Comparable[]我会做错什么这是偷来的密码，我喜欢它，我偷了它 private static void sort(Comparable[] a, Point compPoint, int lo, int hi) { if (hi <= lo) return; i

我有一个

点

类，它实现了

可比

。我想做

点f=arr[first]
现在，我读到使用原始类型Comparableetc是不好的。
因此，如果我将arr[]
类型设置为Comparable[]
而不是Comparable[]
我会做错什么
这是偷来的密码，我喜欢它，我偷了它
private static void sort(Comparable[] a, Point compPoint, int lo, int hi) {
    if (hi <= lo)
        return;
    int lt = lo;
    int gt = hi;
    int i = lo;
    int count = 0;
    Comparator comp = compPoint.SLOPE_ORDER;
    Comparable v = a[lo];
    ArrayList<Point> line = new ArrayList<Point>();
    line.add(compPoint);
    while (i <= gt) {
        int cmp = comp.compare(a[i], v);
        if (cmp < 0)
            exch(a, lt++, i++);
        else if (cmp > 0)
            exch(a, i, gt--);
        else {
            count++;
            line.add((Point) a[i]);
            i++;
        }
    }
    if (count >= 3) {
        Collections.sort(line, new Comparator<Point>() {
            public int compare(Point v, Point w) {
                return v.compareTo(w);
            }
        });
        for (int j = 0; j < line.size(); j++) {
            if (j == line.size() - 1)
                StdOut.println(line.get(j).toString());
            else
                StdOut.print(line.get(j).toString()
                    + " -> ");
        }

        line.get(0).drawTo(line.get(line.size() - 1));
    }

    sort(a, compPoint, lo, lt - 1);
    sort(a, compPoint, gt + 1, hi);
}



private static void exch(Comparable[] a, int v, int w) {
    Comparable tmp = a[v];
    a[v] = a[w];
    a[w] = tmp;
}

private静态无效排序（可比[]a、点compPoint、int-lo、int-hi）{
如果（hi=3）{
Collections.sort（行，新的Comparator（）{
公共整数比较（点v、点w）{
返回v.compareTo（w）；
}
});
对于（int j=0；j ");
}
line.get（0）.drawTo（line.get（line.size（）-1））；
}
排序（a、COMPOINT、lo、lt-1）；
排序（a、COMPOINT、gt+1、hi）；
}
专用静态无效exch（可比[]a，整数v，整数w）{
可比tmp=a[v]；
a[v]=a[w]；
a[w]=tmp；
}

我想知道是否有比让原始类型具有可比性更好的方法。
重构代码以使用泛型没有错。这个方法似乎只用于点
s，所以我选择点【】
，而不是可比【】
。从我看到的情况来看，您还必须重构类和其中ComapratorSLOPE\u ORDER
的compare
方法
如果允许，只需下载所有代码并重构即可。如果它能编译所有的东西，那么这就是java泛型的要点：它在编译时不会出错。在运行时，由于以下原因，它都是原始的。
现在，您可以这样称呼它：
String[] array = {"a", "b"};
sort(array, point, 1, 2);

这显然是荒谬的。比较字符串和点是毫无意义的
该方法中的代码似乎适用于任何类似类型。考虑将签名更改为：
private static <T extends Comparable<T>> void sort(T[] a, T comp, int lo, int hi) {

私有静态无效排序（T[]a，T comp，int lo，int hi）{
以下是您应该做的一系列事情：

类点实现可比
应变为类点实现可比
比较器
应成为比较器
将Comparable[]
替换为Point[]
-如果要将元素强制转换为Point
s，则可以将它们声明为points
替换
Collections.sort(line, new Comparator<Point>() {
    public int compare(Point v, Point w) {
        return v.compareTo(w);
    }
});


为什么你不能编写一个比较器？为什么你不把它做成点[]
？“被盗”类型听起来太错误了：/至少提供一些学分…我编辑了一些代码，如果你们能看到的话，你们会很好的。@A4L：好吧，我未经允许就拿了它，谁知道，作者可能看到了这篇文章，然后像%$#%$#！这里的家伙：？实际上应该是@Eric，不完全是这样。BetterPoint仍然可以使用。使用s上界意味着你可以有一个点数组和一个点超类。子类实例总是可以用来代替命名类——这是OO的主干。我很难弄清楚如何正确地将T[]强制转换为点[]（如果需要的话）另外，既然comp
现在是T类型而不是点，那么将其转换为Point
的最佳方法是什么呢？我尝试了Comparator=（（Point）ref）。SLOPE\u ORDER；
…可以吗？首先它看起来不需要是点，但如果需要，就让数组具有可比性[]，这是唯一的改变
Collections.sort(line);