Which is the difference between Long.valueOf(0) and 0L in Java?

Question

I would like to know the difference between using Long.valueOf(0); or 0L . Are they the same?

I understand that both are Long types so they have a memory consumption of 64-bits long in Java 8.

So how it is better to initialize a variable, considering memory consumption and time complexity?

Long a = Long.valueOf(0);

or

Long b = 0L;

Answer 1

Nothing.

Long b = 0L;

will undergo autoboxing . The compiler replaces it with:

Long b = Long.valueOf(0L);

You can see this if you decompile your class, eg using javap .

void a() {
  Long a = Long.valueOf(0);
}

void b() {
  Long b = 0L;
}

Decompiles to:

  void a();
    Code:
       0: lconst_0
       1: invokestatic  #2                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
       4: astore_1
       5: return

  void b();
    Code:
       0: lconst_0
       1: invokestatic  #2                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
       4: astore_1
       5: return

So how it is better initialize a variable, considering memory consumption and time complexity?

Because they are semantically identical, the memory consumption and time complexity is also identical.

Instead, focus on what is actually important, which is readability : use the one you (and others) will find most easy to understand at a glance.

Answer 2

As others have pointed out, Long l = Long.valueOf(0) and Long l = 0L will compile to the same bytecode, the only difference is style and readability.

Additionally..

It's a bit silly to worry about time complexity for something like this: both expressions are constant time. You usually only talk about time complexity when acting on collections of data not just a single piece of data.

As for memory consumption, they do not use 64 bits as you say; It's the primitive long type that typically uses 64 bits but Long (the wrapper type) uses more memory than the primitive type because it needs that memory for object-related stuff.