Double

In Java a double is twice the size of a float—it is 8 bytes (which is equal to 64 bits). Doubles are used to store floating point values.

We use the Double class to access static methods and constants on a double. We can find useful constants like BYTES but also methods like isNaN to test for special double values.

First example, constants

Here we show some constants on the Double class. We find that the MIN and MAX double values are in a large range.

public class Program {
    public static void main(String[] args) {

        // This is the number of bytes.
        System.out.println(Double.BYTES);

        // Size is the number of bits.
        System.out.println(Double.SIZE);

        // Print min and max.
        System.out.println("MIN: " + Double.MIN_VALUE);
        System.out.println("MAX: " + Double.MAX_VALUE);
    }
}
8
64
MIN: 4.9E-324
MAX: 1.7976931348623157E308

Locals, casts

Next we try casting some doubles. We can convert ints and floats (and other smaller numeric types) to doubles without a cast. This is a widening cast.

public class Program {
    public static void main(String[] args) {

        // Use double local variables.
        double value1 = 1.0d;
        double value2 = 1;
        double value3 = (double) 1;

        // A double can be assigned to a float value.
        float test = 1.0f;
        double value4 = test;

        System.out.println(value1);
        System.out.println(value2);
        System.out.println(value3);
        System.out.println(value4);
    }
}
1.0
1.0
1.0
1.0

Double tests

The Double class has several static methods. These include isNaN, isFinite and isInfinite which tell us things about the double argument we provide.

public class Program {

    static void test(double v) {
        // Use methods to test the double.
        if (Double.isNaN(v)) {
            System.out.println("Not a number");
        }
        if (Double.isFinite(v)) {
            System.out.println("Finite");
        }
        if (Double.isInfinite(v)) {
            System.out.println("Infinite");
        }
    }

    public static void main(String[] args) {

        // An array of doubles.
        double[] values = { Double.NaN,
                Double.NEGATIVE_INFINITY,
                Double.POSITIVE_INFINITY,
                100 };

        // Test all doubles in array.
        for (double v : values) {
            System.out.println(":: TEST ::");
            System.out.println(v);
            test(v);
        }
    }
}
:: TEST ::
NaN
Not a number
:: TEST ::
-Infinity
Infinite
:: TEST ::
Infinity
Infinite
:: TEST ::
100.0
Finite

Truncate

To truncate a double, we can cast it to an int. But this will not always work. We can use a method that combines Math.floor and Math.ceil for correct results.

In my experience double is best reserved for special situations. If floating point is necessary, a double is a simpler choice than float, as floats can be easily cast to doubles.