...

That would be true of any language that is OO.
(And for non-OO languages, other things beside
objects use up memory.)

It depends.  

For example, let's look at one program, designed
two different ways.  Say you have two programs that
each deal with 10,000,000 records from a DataBase.

The code of both apps. might use a common Java Object
to represent each record, but while one program retains
a single instance of the RecordObject, and simply recycles
it for use with each record, the second instantiates 10,000,000
RecordObject's.

The first app. would probably do just fine, whereas the
second would be likely to crash in the standard memory
assigned to Java apps.

The usual advice for Java applications is not to worry
about it until/unless it becomes a problem, then use
a profiler to determine the source of the problem.

To my knowledge, there is no way to ensure no more
references to an object 'by batch'.  Of course, you can
call GC, and any objects with no further references should
be disposed, but I suspect you are referring to something
else.

Java garbage collection is handled automatically for you. If you want
objects to be garbage collected, then drop all of the references to the
object, and it will be collected on the next run.

Other people answered your question, but I wonder if they were assuming you
knew more than you do.  So let me make a few points clear in case you don't
understant the basics of garbage collection.

No.  It's all automatic.  You don't have to worry about that.

if you do something like:

 for (int i=0; i < 1000000; i++) {
   Date d = new Date();
   // do stuff with date
 }

It will create a million Date objects for you, but each Date object is lost
at the end of each iteration of the for() loop, and as such, they are
available for the garbage collector to free them.  The garbage collector
runs automaitcally when it's needed so you just don't worry about it.

However, the better way to write that is something like this (as someone
else already suggested to you):

  Date d = new Date();
  for (int i=0; i < 1000000; i++) {
      // keep reusing the one Date object for each loop
  }

Then you only use up the memory for one Date object and only one Date
object has to be cleaned up after your method terminates.  So as a general
rule, it's better if you don't create lots of objects inside large loops if
you don't need to.  But at the same time, Java object creation and cleanup
is so fast, you can normally get away with doing it the bad way.

The garbage collector will clean up your dead objects for you at some point
in the future.  You normally never have to worry about it.  That's the
beauty of using a gc based language like Java.

You can force the garbage collector to run by calling System.gc() at any
point, but you never need to do that unless you have very special
requirements.  It runs automatically when it's needed.

If you have data you don't need anymore, you can drop your access to it by
setting the object to null.  So for example:

  int a[] = new int[10000000];

Uses up a large chunk of memory which won't be freed as long as you can
access the variable a. But if you are done with the data, you can drop your
access to the array by doing this:

  a = null;

At that point, all the memory used to hold the large array is available for
the gc() to reclaim when it needs more memory.

Normally however, you don't even do that, instead, you just make sure the
life of the variable matches the programs need for the data.  If you only
need that large data for the life of a single method, then you make it a
local variable in the method.  If you only needed it for the life of a
given object, you make it an instance variable in the object.

When you might find a need for that is for class variables (static).  They
stay around for the life of your program, and if there's some point in the
program you don't need them anymore, you can make the memory available for
other use just by setting it to null like above.

As someone else said, the normal practice is to not worry about it until it
becomes a problem.  If you are used to programing in other languages where
you have to carefully alloc and free all your memory and spend all your
life hoping you haven't created a memory leak, it's hard at first to get
used to ignoring it.  But once you get used to the beauty of not having to
worry about memory, you will never want to go back.

On Wed, 12 Sep 2007 01:47:21 GMT, "timothy ma and constance lee"
<timcons1@shaw.ca> wrote, quoted or indirectly quoted someone who said

see http://mindprod.com/jgloss/garbagecollection.html

It happens automatically.