The rules of garbage collection
Although garbage collection does indeed make memory management in Java
a lot easier than it is in C or C++, you aren't able to completely
forget about memory when you program in Java. To know when you may need
to think about memory management in Java, you need to know a bit about
the way garbage collection is treated in the Java specifications.

Garbage collection is not mandated
The first thing to know is that no matter how diligently you search
through the Java Virtual Machine Specification (JVM Spec), you won't be able
to find any sentence that commands, Every JVM must have a garbage
collector. The Java Virtual Machine Specification gives VM designers a
great deal of leeway in deciding how their implementations will manage
memory, including deciding whether or not to even use garbage
collection at all. Thus, it is possible that some JVMs (such as a
bare-bones smart card JVM) may require that programs executed in each
session "fit" in the available memory.

Of course, you can always run out of memory, even on a virtual memory
system. The JVM Spec does not state how much memory will be available
to a JVM. It just states that whenever a JVM does run out of
memory, it should throw an OutOfMemoryError.

Nevertheless, to give Java applications the best chance of executing
without running out of memory, most JVMs will use a garbage collector.
The garbage collector reclaims the memory occupied by unreferenced
objects on the heap, so that memory can be used again by new objects,
and usually de-fragments the heap as the program runs.

Garbage collection algorithm is not defined
Another command you won't find in the JVM specification is All JVMs
that use garbage collection must use the XXX algorithm. The designers
of each JVM get to decide how garbage collection will work in their
implementations. Garbage collection algorithm is one area in which JVM
vendors can strive to make their implementation better than the
competition's. This is significant for you as a Java programmer for the
following reason:

Because you don't generally know how garbage collection
will be performed inside a JVM, you don't know when any particular object will
be garbage collected.

So what? you might ask. The reason you might care when an object is
garbage collected has to do with finalizers. (A finalizer is
defined as a regular Java instance method named finalize()
that returns void and takes no arguments.) The Java specifications make
the following promise about finalizers:

Before reclaiming the memory occupied by an object that has a
finalizer, the garbage collector will invoke that object's finalizer.

Given that you don't know when objects will be garbage collected, but
you do know that finalizable objects will be finalized as they are
garbage collected, you can make the following grand deduction:

You don't know when objects will be finalized.

You should imprint this important fact on your brain and forever allow
it to inform your Java object designs.