Java 不同参数类型（数字）但算法相同的过载

Question

I'm currently has several methods to compare two numbers. They are exact same algorithm, just different parameter types. However, overloading seems too many copy paste.

Current code:

    private boolean isFieldUpdateAllowed(float existingData, float submittedData) {
        if (existingData > 0 && submittedData <= 0) {
            return false;
        }

        if (existingData <= 0 && submittedData > 0) {
            return true;
        }

        if (existingData > 0 && submittedData > 0 && existingData != submittedData) {
            return true;
        }

        return false;
    }

    private boolean isFieldUpdateAllowed(int existingData, int submittedData) {
        if (existingData > 0 && submittedData <= 0) {
            return false;
        }

        if (existingData <= 0 && submittedData > 0) {
            return true;
        }

        if (existingData > 0 && submittedData > 0 && existingData != submittedData) {
            return true;
        }

        return false;
    }

// other numeric type comparison

Any way to simplify the code?

Answer 1

ah yes, silly me... thanks. Using double is good.

No. Wait. Not so fast.

For the integral types, yes, you can replace all of the overloads with a method with long argument types. Other integral types can all be converted to long without any loss of information, and the comparisons will work as expected.

But there is a gotcha when we get to double .

The problem is that a double only has 53 binary bits of precision. So when you convert a large enough long value to a double you get a number that is not mathematically equal to the original value.

So when compare this:

    if (existingData > 0 && submittedData > 0 && existingData != submittedData) {
        return true;
    }

in the long and double cases, for some argument values, the != test with long values will be true , but with the converted double values it will be false ... because of the loss of precision in the conversion.

In short, you have to have overloads for both long and double , or you risk getting incorrect results in some cases.