CODEWITHSUNDEEP
javaperformanceclassdoubleprimitive
Patrick Lorio
Patrick Lorio

Reputation: 5668

Java Double vs double: class type vs primitive type

I was curious to what the performance differences between Java's class and primitive type for double were. So I created a little benchmark and found the class type to be 3x-7x slower than the primitive type. (3x on local machine OSX, 7x on ideone)

Here is the test:

class Main {
    public static void main(String args[]) {
        long bigDTime, littleDTime;

        {
            long start = System.nanoTime();
            Double d = 0.0;
            for (Double i = 0.0; i < 1432143.341; i += 0.1) {
                d += i;
            }
            long end = System.nanoTime();
            bigDTime = end - start;
            System.out.println(bigDTime);
        }

        {
            long start = System.nanoTime();
            double d = 0.0;
            for (double i = 0.0; i < 1432143.341; i += 0.1) {
                d += i;
            }
            long end = System.nanoTime();
            littleDTime = end - start;
            System.out.println(littleDTime);
        }

        System.out.println("D/d = " + (bigDTime / littleDTime));
    }
}

http://ideone.com/fDizDu

So why is the Double type so much slower? Why is it even implemented to allow mathematical operators?

Upvotes: 17

Views: 35997

Answers (3)

entheh
entheh

Reputation: 958

You wouldn't normally use Double, Integer, etc. (Occasionally Integer etc. can be useful to store an 'optional' value - you might want it to be null sometimes. This is less likely with Double because NaN is available for those.)

The reason Double exists is as follows. Java has two main types of value: objects (essentially like C/C++ pointers without the arithmetic), and primitive values (e.g. double). Classes like ArrayList can be defined to accept any Object, which allows users to store String, File or whatever they like in one - but primitive values like double are not covered by such a definition. So classes like Double exist to make it easier for classes like ArrayList to store doubles, without requiring the authors of ArrayList to create special versions for all the primitive types.

Upvotes: 8

user2201345
user2201345

Reputation: 71

Double is a boxed double. Thus in general the compiled code has to check the Double for null before doing anything with it. This is of course slower than doing nothing.

Double (and other boxed versions of the primitives) is useful because it's an Object. This allows you to pass it around to functions that would take an Object, and cast it back to Double somewhere else. More usefully, it allows for generic types to contain it: A generic type cannot contain double or any other primitive, but it can contain a Double.

Upvotes: 4

Jack
Jack

Reputation: 133567

So why is the Double type so much slower?

Because the value is wrapped inside an object which needs allocation, deallocation, memory management plus getters and setters

Why is it even implemented to allow mathematical operators?

Because autobox is meant to allow you to use such wrappers without worrying about the fact that they are not plain values. Would you prefer not being able to have an ArrayList<Double>? Performance is not always necessary and a drop of 3x-7x of performance according to situations maybe acceptable. Optimization is a requirement which is not always present.

This is true in every situation, using a LinkedList to random access elements could be overkill but this doesn't mean that LinkedList shouldn't be implemented at all. This neither means that using a linked list for few random accesses could interfere with performance so much.

A final note: you should let the VM warm up before benchmarking such things.

Upvotes: 22

Related Questions