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.

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.

The absolute quantity of information that you can store in 64 bit is of course the same.

What changes is the meaning you assign to the bits.

In an integer or long variable, the codification used is the same you use for decimal numbers in your normal life, with the exception of the fact that number two complement is used, but this doesn't change that much, since it's only a trick to gain an additional number (while storing just one zero instead that a positive and a negative).

In a float or double variable, bits are split in two kinds: the mantissa and the exponent. This means that every double number is shaped like XXXXYYYYY where it's numerical value is something like XXXX*2^YYYY. Basically you decide to encode them in a different way, what you obtain is that you have the same amount of values but they are distribuited in a different way over the whole set of real numbers.

The fact that the largest/smallest value of a floating number is larger/smaller of the largest/smalles value of a integer number doesn't imply anything on the amount of data effectively stored.

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).

Though not a replacement, you can use java.lang.math.BigDecimal.You can roughly store billion of digits until you run out of memory. Its an arbitrary precision class, it will get as large as you'd like until your computer runs out of memory.

As per the documentation of BigDecimal:

Immutable, arbitrary-precision signed decimal numbers. A BigDecimal consists of an arbitrary precision integer unscaled value and a non-negative 32-bit integer scale, which represents the number of digits to the right of the decimal point. The number represented by the BigDecimal is (unscaledValue/10scale). BigDecimal provides operations for basic arithmetic, scale manipulation, comparison, hashing, and format conversion.