http://www.mspaintadventures.com/?s=6&p=002219

:D

As the reference says:

Quote:


You may have your reasons to use a HashMap and not a simple Array. It all depends on what you want to do...

The thing is, since it is a HashMap (and not an Array), you cannot iterate through it as you would do with an Array. You need an Iterator.

An iterator is just a tool that will help you to retrieve each element of the HashMap. It's a three-step procedure :

1. get an iterator from the hashmap
2. see if it can retrieve the next element
3. get the next element and back to step #2

You would do quite the same with an array (but the syntax is different, because Arrays and HashMaps are different) :

1. get the array's length
2. see if you have reached this length
3. get the current element and back to step #2

The last 2 posts gave good explanations of HashMap/Iterator and perhaps messing about with the code below might help.



Code:

class Employee {
  private String socialSecurityNumber;
  private String lastName;
  private String firstName;

  public Employee(String ssn, String lname, String fname){
    socialSecurityNumber = ssn;
    lastName = lname;
    firstName = fname;
  }
  public String getSocialSecurityNumber(){
    return socialSecurityNumber;
  }
  public String toString(){
    return socialSecurityNumber + " " + lastName + " " + firstName;
  }
}

void setup(){
  size(200,200);
  HashMap myMap;
  Employee emp, emp2;

  myMap = new HashMap();
  emp = new Employee ("12 45 67 89 C", "Smith", "John");
  myMap.put(emp.getSocialSecurityNumber(), emp);
  emp = new Employee ("11 22 33 44 Y", "Brown", "David");
  myMap.put(emp.getSocialSecurityNumber(), emp);

  if (myMap.containsKey("12 45 67 89 C")){
    emp2 = (Employee) myMap.get("12 45 67 89 C");
    println("Map contains key: " + emp2);
  }
  if (myMap.containsValue(emp)){
    emp2 = (Employee) myMap.get(emp.getSocialSecurityNumber()); 
    println("Map contains value: " +  emp2);
  }
  displayMapContents(myMap);
  println("Map has 2 entries" + myMap.size());
  myMap.clear();
  println("Map is now " + (myMap.isEmpty() ? "empty" : "not empty"));
}

void displayMapContents(HashMap hm){
  Iterator i = hm.entrySet().iterator();  // Get an iterator

  while (i.hasNext()){
    Map.Entry me = (Map.Entry)i.next();
    print(me.getKey() + " is ");
    println(me.getValue());
  }
}
 

I interpret the code as follow:
- read team information, a list of code & name pairs, whatever it is.
- store this information in arrays, for fast retrieval by index.
- store in a HashMap the index of each team, using the team code as key: thus, if one provides a code (be it 549, AZX or whatever), they can get the corresponding index, and thus the team name.
An alternative could be to store the name along the code in the hash map, but this solution has at least an advantage: it preserves the original team order, which might have an importance, and still allows iterating over that array in order.

Yes to all your questions!
With a precision. Casting isn't exactly ""wrapping" a variable type in another variable type", or rather there are restrictions in this wrapping. You cannot cast a PImage into a PVector for example. You can cast a generic type (eg. a List) to a specialized type (eg. an ArrayList). Cast of primitives (float to int) are a different problem.
In old Java (before 1.5, we still use the 1.4 syntax in Processing), lists, maps and other collections were generic (able to hold any kind of object), but for this, they hold actually only the Object type. Object is the fundamental class: all other classes are an extension of it (it has generic methods like toString, hash, etc.).
So when you do myMap.put(stuff), the stuff is internally stored as a plain anonymous Object. Although it has still information on what it is actually, the map see it only as an Object.
And when you do emp = myMap.get(id), you get an Object, but since you want an Employee, you have to cast it, to put the "virgin" object into shape.