If you have a special need for some special order (i.e. not
lexigraphical order) of the two letter codes to be maintained, use a
LinkedListMap instead of a TreeMap.

   Use the two letter codes as the keys in the map, and the objects you're
mapping to as the values.

<PHP code>
$myMap['AA'] = myObject1;
$myMap['AB'] = myObject2;
$myMap['CZ'] = myObject3;
...

//Do something will all the objects
foreach($myMap as $key => $value) {
 doSomething($value);
}

//Do something with only object CZ
doSomething($myMap['CZ']);
</PHP code>

<Java 1.4 code>
Map myMap = new LinkedListMap(); /*Synchronize this if you want*/
myMap.put("AA", myObject1);
myMap.put("AB", myObject1);
myMap.put("CZ", myObject1);
...
//Do something will all the objects
Iterator valueIterator = myMap.valueSet().iterator();
while (valueIterator.hasNext()) {
 MyObjectClass moc = (MyObjectClass)valueIterator.next();
 moc.doSomething();
}
//Do something with only object CZ
MyObjectClass moc = (MyObjectClass)myMap.get("CZ");
moc.doSomething();
</Java 1.4 code>

<Java 1.5 code>
Map<String,MyObjectClass> myMap = new LinkedListMap<String,MyObjectClass>();
/*Synchronize this if you want*/
myMap.put("AA", myObject1);
myMap.put("AB", myObject1);
myMap.put("CZ", myObject1);
...
//Do something will all the objects
for (MyObjectClass moc : myMap.valueSet()) {
 moc.doSomething();
}

//Do something with only object CZ
myMap.get("CZ").doSomething();
</Java 1.5 code>

   - Oliver

I haven't yet moved to Java 1.5 and generics, so I'll couch responses in
terms of 1.4.2 and earlier.

I used the term "index" in an effort to make it familiar to your
original inquiry about an array.  But there's not really an index --
there's not an array.  A map is a collection of key-value pairs.  There
are objects serving as entries in a map and there are other objects
which are the keys used to find each particular entry.

Your original inquiry referred to some languages supporting associative
arrays, and with a map you could indeed use "AA" much like an array
index reference.  That's what I was attempting to describe in my reply.  
I envisioned that you wanted an array something like this:

[AA] --> someObject1
[AB] --> someObject2
[AC] --> someObject3
[BA] --> someObject4
[BB] --> someObject5

So the map would take calls like this:

put("AA", someObject1);
put("AB", someObject2);
put("AC", someObject3);

And so on...  Each such call specifies an object that will serve as a
key, and an object which will be the value.

To get a specific object, you could use get("AA").  It could be null if
you never added anything using "AA" as a key, or if you actually made a
null entry.  If you're using Java 1.5, with generics, you can specify
the type at compile time that you'll put into your map, whereas 1.4.2
and earlier will return an Object and you'll have to cast it to whatever
type it really is.  Unlike an array, though, there's not an "empty spot"
if you don't provide, for instance, a value keyed to "CC" -- it's simply
not there.

I mentioned the TreeMap only because it allows you to iterate over the
contents and have them come out in the order of the keys.  If you don't
need to iterate, or don't care about the order in which they come out
during iteration, a HashMap would be better.

Hope this helps clarify.

= Steve =