Comparable<type> 数组 VS Comparable 数组答案

【问题标题】：Comparable< type > array VS Comparable arrayComparable<type> 数组 VS Comparable 数组
【发布时间】：2013-09-22 21:29:18
【问题描述】：

我有一个实现Comparable 的Point 类。我想做Point f = arr[first];

现在，我读到使用原始类型 Comparable 等是不好的。那么，如果我将arr[] 设为Comparable<Point>[] 而不是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;
}

我想知道是否有比使用原始类型 Comparable 更好的方法。

【问题讨论】：

为什么不能写Comparator？
你为什么不把它变成Point[]类型？
"stolen" 听起来太错误了：/ 至少提供一些学分...
我编辑了一些代码，如果你们能看到的话，会很感激你们。 @A4L：好吧，我未经许可就拿走了，谁知道呢，作者可能看到了这篇文章，然后像 %$#%$#！
这里的人：github.com/arhangeldim/coursera/blob/master/Fast.java?

标签： java arrays generics

【解决方案1】：

现在，你可以这样称呼它：

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 extends Comparable<? super T>>，这样就可以使用定义为BetterPoint extends Point的类了
@Eric 不完全是。 BetterPoint 仍然可以使用。使用超界意味着您可以拥有一个 Point 数组和一个 Point 超类。总是可以使用子类实例而不是命名类 - 这是 OO 的支柱。
我无法弄清楚如何正确地将 T[] 转换为 Point[]（如果需要的话）。另外，由于 comp 现在的类型是 T 而不是 Point ，将其转换为 Point 的最佳方法是什么？我试过Comparator<Point> comp = ((Point) ref).SLOPE_ORDER; ...可以吗？
起初它看起来不需要是一个点，但如果是，只需将数组设为Comparable<Point>[] 并使其成为唯一的更改

【解决方案2】：

重构代码以使用泛型并没有错。似乎此方法仅用于Points，所以我会使用Point[] 而不是Comparable<Point>[]。据我所知，您还必须在其中重构 Point 类和 Comaprator SLOPE_ORDER 的 compare 方法。

如果允许，只需下载所有代码并重构它。如果它编译一切都会好的，那么这就是java泛型的重点：它有助于在编译时不做错任何事。由于type erasure，在运行时无论如何都是原始的。

【讨论】：

【解决方案3】：

以下是你应该做的一堆事情：

class Point implements Comparable 应该变成 class Point implements Comparable<Point>
Comparator 应该变成 Comparator<Point>
将Comparable[] 替换为Point[] - 如果要将元素转换为Points，不妨将它们声明为点

替换

Collections.sort(line, new Comparator<Point>() {
    public int compare(Point v, Point w) {
        return v.compareTo(w);
    }
});

冗余较少

Collections.sort(line);

【讨论】：