为什么operator <Java泛型有编译器错误？

Question

Why does the condition key < x[mid] below cause the compiler to complain that the operator is undefined?

In C++ this would be a compile time warning only if the type T didn't support operator < semantics. How do you do the equivalent in Java?

package search;

    public class BinarySearch<T>
    {
        public boolean binary_search_iterative (T[] x, T key)
        {
            int size = x.length;
            if ( size == 0 ) { return false; }

            int end = size - 1;

            int start = 0;

            while ( start <= end)
            {
                int mid = (end + start)/2 ;
                if (key < x[mid])
                {
                    end = mid - 1;
                }
                else if ( key > key[mid])
                {
                    start = mid + 1;
                }
                else
                {
                    return true;
                }
            }

            return false;
        }
    }

Answer 1

There is no operator overloading in Java. To obtain a similar result you should look into Comparable<T> which is meant to provide the same functionality to objects.

So in your case it would be:

key.compareTo(x[mid]) < 0

But to make this work you must provide a bounded type variable, T is not enough because the compiler can't infer that types what used in place of T implement Comparable so you should use:

public class BinarySearch<T extends Comparable<T>>

This because generics are not implemented like in C++ in which templates are built during compilation phase according to the types that use them. You must explicitly state what your T is because the type checker requires so.

Answer 2

In Java you cannot overload operators.

The way this would normally be solved is to have your key class implement the Comparable<T> interface, and override its compareTo() method.

You would then limit your type parameter T to only types that implement Comparable, eg:

BinarySearch<T extends Comparable<T>>

And use compareTo() instead of < .

Answer 3

In C++ this would be a compile time warning only if the type T didn't support operator < semantics.

Correct. In Java there are no types T that can be used in a generic declaration that do support operator <. So you get a compilation error.

Answer 4

T is autoboxed always to an Object. < is allowed for primitive numbers in java only.

Try this for any primitive numbers or classes that extends from Number :

package search;

public strictfp class BinarySearch<T extends Number>
{
    public boolean binary_search_iterative (T[] x, T key)
    {
        int size = x.length;
        if ( size == 0 ) { return false; }

        int end = size - 1;

        int start = 0;

        while ( start <= end)
        {
            int mid = (end + start)/2 ;
            if (key.doubleValue() < x[mid].doubleValue())
            {
                end = mid - 1;
            }
            else if ( key.doubleValue() > x[mid].doubleValue())
            {
                start = mid + 1;
            }
            else
            {
                return true;
            }
        }

        return false;
    }

    public static void main(String[] args) {
        BinarySearch<Integer> bs = new BinarySearch<Integer>();
        bs.binary_search_iterative(new Integer[]{1,2}, 2);
    }
}