It uses a different representation (floating point) using exponents and mantissa

For details see IEEE754

Double.MAX_VALUE is the maximum value a double can represent (somewhere around 1.7*10^308).

This should end in some calculation problems, if you try to subtract the maximum possible value of a data type.

Even though when you are dealing with money you should never use floating point values especially while rounding this can cause problems (you will either have to much or less money in your system then).

If you are storing integers, use Long. Your statement that "Advantage of Using Double is that it gives a more wider range for storing Whole Numbers" is incorrect. Both are 64 bits long, but double has to use some bits for the exponent, leaving fewer bits to represent the magnitude. You can store larger numbers in a double but you will lose precision.

In other words, for numbers larger than some upper bound you can no longer store adjacent "whole numbers"... given an integer value above this threshold, the "next" possible double will be more than 1 greater than the previous number.

For example

public class Test1  
{

    public static void main(String[] args) throws Exception 
    {
        long   long1 = Long.MAX_VALUE - 100L;
        double dbl1  = long1;
        long   long2 = long1+1;
        double dbl2  = dbl1+1;
        double dbl3  = dbl2+Math.ulp(dbl2);

        System.out.printf("%d %d\n%f %f %f", long1, long2, dbl1, dbl2, dbl3);
    }

}

This outputs:

9223372036854775707 9223372036854775708
9223372036854776000.000000 9223372036854776000.000000 9223372036854778000.000000

Note that

1. The double representation of Long.MAX_VALUE-100 does NOT equal the original value
2. Adding 1 to the double representation of Long.MAX_VALUE-100 has no effect
3. At this magnitude, the difference between one double and the next possible double value is 2000.

Another way of saying this is that long has just under 19 digits precision, while double has only 16 digits precision. Double can store numbers larger than 16 digits, but at the cost of truncation/rounding in the low-order digits.

If you need more than 19 digits precision you must resort to BigInteger, with the expected decrease in performance.

This is because of the loss of precision while converting long to double

    double d1 = (double)Long.MAX_VALUE;
    double d2 = Long.MAX_VALUE + 1.0;
    System.out.println(d1);
    System.out.println(d2);

it gives the same numbers

9.223372036854776E18
9.223372036854776E18

long has 32 bits and double's significand has 53 bits http://en.wikipedia.org/wiki/Double-precision_floating-point_format. In decimal terms, max long = 9223372036854775807, it is 19 digits, and double can hold 17 max

Long.MAX_VALUE - Long.MIN_VALUE is higher than Long.MAX_VALUE, which is why this subtraction results in numeric overflow. Therefore you don't get the correct result.

The range of numbers represented by the double type is wider, at the price of a lower precision (since some of the bits represent the digits of the number while the rest represent the exponent).

The fact that both long and double types use 64 bits to represent numbers doesn't mean they both support the same range of values. They don't.

The max value that can be represented by a double is 1.7976931348623157E308, while the max value that can be represented by a long is 2^63-1, which is much smaller (9.223372036854776E18).

tl;dr

For population of humans, use long primitive or Long class.

Details

The floating-point types trade away accuracy in exchange for speed of execution. These types in Java include float/Float and double/Double.

If working with whole numbers (no fractions):

• For smaller numbers ranging from -2^31 to 2^31-1 (roughly plus or minus 2 billion , use int/Integer. Needs 32-bits for content.
• For larger numbers, use long/Long. Needs 64-bits for content.
• For extremely large numbers, use BigInteger.

If working with fractional numbers (not integers):

• For numbers between (2-2^-23) * 2^127 and 2^-149 where you do not care about accuracy, use float/Float. Needs 32-bits for content.
• For larger/smaller numbers where you do not care about accuracy, use double/Double. Needs 64-bits for content.
• For more extreme numbers, use BigDecimal.
• If you care about accuracy (such as money matters), use BigDecimal.

So for the earth’s population of humans, use long/Long.

That method can't return true. That's the point of Long.MAX_VALUE. It would be really confusing if its name were... false. Then it should be just called Long.SOME_FAIRLY_LARGE_VALUE and have literally zero reasonable uses. Just use Android's isUserAGoat, or you may roll your own function that always returns false.

Note that a long in memory takes a fixed number of bytes. From Oracle:

long: The long data type is a 64-bit signed two's complement integer. It has a minimum value of -9,223,372,036,854,775,808 and a maximum value of 9,223,372,036,854,775,807 (inclusive). Use this data type when you need a range of values wider than those provided by int.

As you may know from basic computer science or discrete math, there are 2^64 possible values for a long, since it is 64 bits. And as you know from discrete math or number theory or common sense, if there's only finitely many possibilities, one of them has to be the largest. That would be Long.MAX_VALUE. So you are asking something similar to "is there an integer that's >0 and < 1?" Mathematically nonsensical.

If you actually need this for something for real then use BigInteger class.