Why do people still use primitive types in Java?

In Joshua Bloch's Effective Java, Item 5: "Avoid creating unnecessary objects", he posts the following code example:

public static void main(String[] args) {    Long sum = 0L; // uses Long, not long    for (long i = 0; i <= Integer.MAX_VALUE; i++) {        sum += i;    }    System.out.println(sum);}

and it takes 43 seconds to run. Taking the Long into the primitive brings it down to 6.8 seconds... If that's any indication why we use primitives.

The lack of native value equality is also a concern (.equals() is fairly verbose compared to ==)

for biziclop:

class Biziclop {    public static void main(String[] args) {        System.out.println(new Integer(5) == new Integer(5));        System.out.println(new Integer(500) == new Integer(500));        System.out.println(Integer.valueOf(5) == Integer.valueOf(5));        System.out.println(Integer.valueOf(500) == Integer.valueOf(500));    }}

Results in:

falsefalsetruefalse

_^EDIT Why does (3) return true and (4) return false?

Because they are two different objects. The 256 integers closest to zero [-128; 127] are cached by the JVM, so they return the same object for those. Beyond that range, though, they aren't cached, so a new object is created. To make things more complicated, the JLS demands that at least 256 flyweights be cached. JVM implementers may add more if they desire, meaning this could run on a system where the nearest 1024 are cached and all of them return true... #awkward

Autounboxing can lead to hard to spot NPEs

Integer in = null;......int i = in; // NPE at runtime

In most situations the null assignment to in is a lot less obvious than above.

Boxed types have poorer performance and require more memory.