The garbage collector of Java works 'in the backdoor' collecting everything without a current reference pointing to the memory allocation --automatically- , thus there´re no destructors as in C.
I think you might use a List instead of an array, thus when a object is not necessary you can remove the reference from the list letting the garbage collector do its job:
· If elements to be removed are always at the extremes of the list because you assign alpha secuentially: use an ArrayList.
· If these could be random elements in the middle of the group (because of a random alpha i.e.): use LinkedList instead.
(An ArrayList is stored in a contiguous piece of memory, so if you remove an element from the middle you have to copy all the elements to a new ArrayList in other place. A LinkedList sorts this out because it has links from one element to next and previous and the memory allocation, thus, may be fragmented)
Hope this helps!
Regards!

Ale · http://60rpm.tv/i

If you do a

<Your object reference> = null;

This is a very strong hint to the Java garbage collector that the memory can be freed.

You can also request a garbage collection with the statement

1. System.gc();

Ale_, how do you make a linked list without pointers?

Mmm, I did this little sketch to show you how to use it. I´ve added it some stuff because quarks is absolutely right. One thing is to "kill" an object cleaning the reference and other one is the job of the garbage collector. If you check the sketch you will see there´s a method called finalize() on the class Cloud. Finalize() method is useful if you want an object to perform a task before being collected by the GC. In this case finalize() simply tells us an object has been collected. If you don´t include this line "if(k>=20){System.gc(); k=0;}" you will see that although the list contains lesser objects as time goes by, the garbage collector is doing nothing at all. So it´s a nice idea to call the GC when you reach a significative level of memory trash to clean. In this case 20, but I´d set that level to higher numbers... all depending on how memory costs each object Cloud to the heap. It´s not a good idea to call it often, I think, only as it becomes necessary.
You can also try what byhring said, it is also a good idea. You only have to think how to deal with the exceptions in a simple array... but that´s not tough... ;-)


  LinkedList <Cloud> clouds;
  int cloudsNumber=50;
  float alphaLimit=.5;
  int k=0;
 
  void setup(){
    size(500,500);
    background(-1);
    smooth();
    clouds = new LinkedList<Cloud>();
    for (int i=0; i<cloudsNumber;i++) { clouds.add(new Cloud()); }
  }
 
  void draw(){
    for (int i=0; i<clouds.size(); i++) {
      Cloud c= clouds.get(i);
      c.render();
      c.update();
      if(c.alpha<5) {clouds.remove(c); println(clouds.size());}
    }
    if(k>=20){System.gc(); k=0;}
  }
 
  class Cloud {
   float alpha,x,y,R;
 
   Cloud(){
     alpha=random(255);
     x=random(width);
     y=random(height);
     R=100;
   }
   
   void render(){
     fill(0,alpha);
     stroke(-1,alpha);
     ellipse(x,y,R,R);
   }
  
   void update(){
     alpha-=.5;
     R-=.5;
   }
  
   void finalize(){ println("Garbage collector took one more"); }
  
  }

Ale · http://60rpm.tv/i

" how do you make a linked list without pointers?"
Java has no pointers but works with refernces.
If you do:
Ball b = new Ball();
b actually just hold a reference to the new object.
If you do:
Ball a = b;
unlike what lot of people thing, you haven't done a copy but you assigned a reference to the same object: changing the content of b also change the content of a (actually, it changes the object referenced by the two variables).
Same for objects put in an array list: they can be held in several array lists, some variables, etc.
When an object is no longer referenced by anything, the garbage collector will eventually spot it and delete it.

Linked list: each item of the list has thus a reference on the next one (and the previous one if that's a doubly-linked list).