You can create an array of objects easily:

Code:

MyObj[] thing=new MyObj[10];
//an array of 10 MyObj-es 

As for sorting, if your class implements the Comparable interface, to do sorting, you can use Arrays.sort(thing); where thing is the array of 10 MyObj-es

Unfortunately there's no magic "find every Foo object that exists in the code and put it into an array" sorry, you have to do that yourself.

The Comparable interface is a Java thing, but you can use all Java stuff in processing. You'd go about using it like:

Code:

class MyObj implements Comprabale
{
  int x,y;
  MyObj(...)
  // normal stuff that you use anyway...

  //if we want to sort based on the X value of MyObj-es:
  int compareTo(Object o)
  {
    MyObj other=(MyObj)o;
    if(other.x>x) 
	return -1;
    if(other.x==x)
	return 0;
    else
	return 1;
  }
} 

IF you create an array of MyObj-es then call Arrays.sort(theMyObjArray); it'll be sorted based on the X value in each MyObj.

In truth, Processing does not provide a language in a true sense - it provides a preprocessor that takes line-level valid Java code you input as "Processing code" into the Processing Development Environment (PDE), embeds it in code for Java classes, compiles the assembled Java files, and executes the resultant byte code. Therefore, you pick up all the benefits and limitations of Java as a language and runtime (Java Virtual Machine) environment.

Therefore, when you say that Processing does not have a way to find all instances of class Foo, you really mean Java. Java does not have a built-in "object space" accessible via the standard library that allows you to find all instances of a class, but many other languages like Smalltalk and Ruby do. For example:

http://www.ruby-doc.org/docs/ProgrammingRuby/html/ospace.html

To roughly approximate using Java, you can, instead of creating an object like so:

Foo foo = new Foo();

Create a static class method to create new Foo instances:

Foo foo = Foo.instance();

Implement Foo.instance() to construct a new instance, add a reference to the new instance in a class variable collection, and then return the new instance. Then implement a:

Collection foos = Foo.instances();

Static class method that returns the Collection of Foos kept in the class variable (maintain care if modifying the returned collection - you may want to clone the collection).

Of course, you need to analyze whether you really need this at the class level. Often, a design that necessitates this indicates an overall application design flaw and will reduce to a simpler pattern.

Thanks, smith.  I am indeed simplifying the design to avoid needing the object space, but this has been a pretty fascinating discussion for me.  I have never tried to learn Smalltalk or Ruby and wasn't aware that any language implements such a thing.  Definitely something to think about as I get more into OO design.