嘗試執行通用二進制搜索時，方法不能應用于給定型別

假設我有一個名為RandomObject：

public class RandomObject implements Comparable<RandomObject> {

    private String name;
    private int value;

    public RandomObject(String name, int value) {
        this.name = name;
        this.value = value;
    }

          . 
          .
          .

    public int compareTo(RandomObject rn) {
        return Integer.compare(value, rn.value);
    }

這個 s 陣列RandomObject（每個都持有一個隨機的 int 值，用于比較目的）：

RandomObject[] arr = new RandomObject[10];
for (int i = 0; i < arr.length;   i) {
        arr[i] = new RandomObject(" ", (int) (Math.random() * 50));
    }

我還有一個名為Quicksort包含以下排序方法的類：

public static <T extends Comparable<? super T>> void sort(T[] a) {
    sort(a, 0, a.length - 1);
}

 public static <T extends Comparable<? super T>> void sort(T[] a, int start, int end) {
    int left = start, right = end;
    T pivot = a[(left   right) / 2];

    do {
        while (a[left].compareTo(pivot) < 0) {
            left  ;
        }
        while (a[right].compareTo(pivot) > 0) {
            right--;
        }
        if (left <= right) {
            T temp = a[left];
            a[left  ] = a[right];
            a[right--] = temp;
        }
    } while (left <= right);

    if (start < right) {
        sort(a, start, right);
    }
    if (left < end) {
        sort(a, left, end);
    }
}

呼叫Quicksort.sort(arr)正常作業并按值排序arr。

但是，我也有一個BinarySearch具有以下search方法的類：

public static <T extends Comparable<? super T>> int search(T[] a, T value) {
    int start = 0, end = a.length - 1;
    do {
        int mid = start   (end - start) / 2;
        if (a[mid].compareTo(value) == 0) {
            return mid;
        } else if (a[mid].compareTo(value) > 0) {
            end = mid;
        } else {
            start = mid   1;
        }
    } while (start < end);
    return -1;
}

當我嘗試執行這樣的搜索時：

Integer x = 2;
System.out.println("Trying to find x: "   BinarySearch.search(arr, x));

出了點問題：

“java：類 br.com.algorithms.BinarySearch 中的方法搜索不能應用于給定型別；
必需：T[],T
找到：br.com.algorithms.RandomObject[],java.lang.Integer
原因：推理變數 T具有不兼容的邊界
下界：br.com.algorithms.RandomObject,java.lang.Integer,java.lang.Comparable<? super T>
下界：java.lang.Integer,br.com.algorithms.RandomObject"

不存在型別變數的實體，因此 RandomObject 符合 Integer

我很難理解為什么該sort方法有效，而search在這種情況下該方法無效。如果兩種方法都需要T[]并且我同時提供RandomObject[]這兩種情況，為什么不編譯搜索？這里有什么區別？

uj5u.com熱心網友回復：

這里有什么區別？

search帶 aT[]和 a T，表示第一個引數的陣列元素型別需要和第二個引數的型別相同。你給了它RandomObject[]and Integer，這顯然是無效的。

另一方面，sort只需要一個T[]，所以你可以給它任何參考型別的陣列，并且引數之間沒有進一步的約束。畢竟，只有一個引數。

RandomObject[]請注意，使用當前實作不可能在 a 中搜索整數。這是因為compareTo比較RandomObject. 它不會將RandomObjects 與Integers 進行比較。

相反，您可以做的是RandomObject使用創建一個“虛擬” x，并將其傳遞給search：

int x = 1;
RandomObject key = new RandomObject("this does not matter", x);
System.out.println("Trying to find x: "   BinarySearch.search(arr, key));

search您還可以創建僅搜索的非通用版本RandomObject[]。在這個非通用版本中，您可以將第二個引數更改為int：

public static int search(RandomObject[] a, int value) { ... }

但是在通用方法中，很難知道呼叫者想要搜索什么鍵。但這并非不可能 - 您可以創建這樣的界面：

interface BinarySearchableByKey<T extends Comparable<? super T>> {
    T getKey();
}

應該實作而不是（或除了）實作Comparable，因為它可以通過整數鍵搜索。RandomObjectBinarySearchableByKey<Integer>

public class RandomObject implements BinarySearchableByKey<Integer> {
    // ...

    @Override
    public Integer getKey() { return value; }
}

更改search為具有兩個型別引數 - 陣列的型別和搜索鍵型別：

public static <K extends Comparable<? super K>, T extends BinarySearchableByKey<? extends K>> int search(T[] a, K value) {
    int start = 0, end = a.length - 1;
    do {
        int mid = start   (end - start) / 2;
        if (a[mid].getKey().compareTo(value) == 0) {
            return mid;
        } else if (a[mid].getKey().compareTo(value) > 0) {
            end = mid;
        } else {
            start = mid   1;
        }
    } while (start < end);
    return -1;
}

uj5u.com熱心網友回復：

如果兩種方法都需要 T[] 并且我為這兩種情況提供 RandomObject[]

二分搜索引數需要兩件事： aT[]和 a T。

您正在提供 aRandomObject[]和Integer. 這些不是相同的 T。您的二進制搜索方法需要 aRandomObject[]和 a RandomObject。

標籤：爪哇仿制药类型可比

上一篇：Java流中間操作是否會多次迭代流？

下一篇：為什么我的單鏈表沒有被正確賦值？