i think this in updateWord is wrong (or at least inefficient)

1.       ArrayList temp = (ArrayList) fileIndices.get(fileName);
2.       temp.add(new Integer(index));
3.       fileIndices.put(fileName, temp);

and it would be possible to

fileIndices.get(filename).add(new Integer(index));

(ie get the arraylist associated with this file and add the new index to it)

but i do know that your Integer class really shouldn't be there - it'll get in the way of the standard Integer class. just use the real one instead.

fileIndices.get(filename).add(new Integer(index));

It is better to use:

1. fileIndices.get(filename).add(Integer.valueOf(index));

instead... It might create less objects, thus is faster in general.

Okay, I've been doing some more tinkering and I feel I've gotten a bit wiser. Here's a new test sketch that seems to be working. I'll try it with some real files soon.The thing that's been stumping me is that even though I populate the ArrayList with int's, when I retrieve them they come back as 'Objects'. I don't know how to convert them to int's. HOWEVER I did find a nifty toString() method for the ArrayList class in the javadocs. With that I could first convert to string and then to int. (see lines 61-64). What I found curious was that I couldn't return int(r) directly, but had to cast it first: (int) int(r). Don't know why, but that works!

1. /* Word Class, another attempt at using a HashMap within the class
   
2. */
3. class Word {
4.   String word;                 //The word to be tracked
5.   int count;                      //Global count of occurrences of word
6.   HashMap fileIndexes;  //maps filenames to ArrayList of ints
7.  
8.   // CONSTRUCTORS
9.   Word() {            //Null-arg constructor
10.     fileIndexes = new HashMap();
11.   }
12.  
13.   Word(String word, String fileName, int index) {
14.     fileIndexes = new HashMap();
15.     this.word = word;
16.     count = 1;
17.    
18.     fileIndexes.put(fileName,new ArrayList());
19.     ArrayList temp = (ArrayList) fileIndexes.get(fileName);
20.     temp.add(index);
21.   }
22.  
23.   // METHODS
24.   void printWord() {
25.     print("\nThe word: "+word);
26.     int s = fileIndexes.size();
27.     println(" appears "+count+" times in "+s+" files. ");
28.     Iterator i = fileIndexes.keySet().iterator();
29.    
30.     while(i.hasNext()){
31.       String w = (String) i.next();
32.       print(w+" @ ");
33.       ArrayList temp = (ArrayList) fileIndexes.get(w);
34.       println(temp);
35.        
36.     }
37.     println();
38.    
39.   }
40.  
41.   void addFile(String fileName, int index) {
42.     ArrayList temp = new ArrayList();
43.     temp.add(index);
44.     fileIndexes.put(fileName, temp);
45.     count++;
46.   }
47.  
48.   void updateFile(String fileName, int index) {
49.     ArrayList temp = (ArrayList) fileIndexes.get(fileName);
50.     temp.add(index);
51.     fileIndexes.put(fileName, temp);
52.     count++;
53.   }
54.  
55.   int getNthIndex(String fileName, int nth) { // return the index value of the Nth occurrence
56.     ArrayList temp = (ArrayList) fileIndexes.get(fileName);
57.     if(nth>temp.size()) {
58.       return(-1);  // return -1 if request is out of bounds
59.     }
60.     else {
61.       String r = (String) temp.get(nth).toString();
62.       //int rr = int(r);
63.       //return(rr);
64.       return( (int) int(r) );
65.     }
66.   }
67.  
68. }

koogy, I hope you don't mind if I correct your helpful remarks...
I don't know why you mention Long type, as it isn't mentioned earlier in the thread.
Beside, (Long)temp.get(nth).intValue(); won't do what you expect (but I haven't tested either...): if I am not mistaken, it will apply intValue() to the result of get(), which won't compile if the ArrayList isn't typed (as you shown it can be). Then it will cast the result to Long, which probably fails too (casting a primitive value to an object, I don't thing autoboxing will work there).
It is better to do: ((Long) temp.get(nth)).intValue(); ie. cast the result of get() to Long (supposing it was what was put there, otherwise (Integer) cast is needed) then get its intValue().

To procklipressing: In Java, thus Processing, int and Integer are different things (and long and Long, Boolean and boolean, etc.).
The first one is a primitive type, taking a small amount of memory. The second one is an object, wrapping up the int value, offering some methods on it, making it slower and bigger, but allowing it to be accepted by collections like ArrayLists, which handle only objects.
Since Java 1.5, the frontier is blurred by the auto(un)boxing feature, where you can do:

1. int ip = 42;
2. Integer io = ip;

while previously you had to do something like Integer io = new Integer(ip); ie. explicitly wrap the primitive value in an object.
Last note about Integer.valueOf(ip): it handles a small pool of created objects of this type: so if it is already allocated, it returns the existing object instead of creating a duplicate object. Useful if you have a million of such objects for example, with lot of duplicates.

Thanks all, this is proving to be a valuable education.

To procklipressing: In Java, thus Processing, int and Integer are different things (and long and Long, Boolean and boolean, etc.).
The first one is a primitive type, taking a small amount of memory. The second one is an object, wrapping up the int value, offering some methods on it, making it slower and bigger, but allowing it to be accepted by collections like ArrayLists, which handle only objects.

For example, that was something about which I had no idea. I assumed that if I populated an ArrayList with int's, I would get int's out when I called ArrayList.get(). I quickly learned that even though I used ArrayList.put(int i), the ArrayList turned them into objects. Ignorant of the Integer class, I was also ignorant of any way to extract an int value. So thanks!

 Also, this little nugget is especially illuminating:

Beside, (Long)temp.get(nth).intValue(); won't do what you expect (but I haven't tested either...): if I am not mistaken, it will apply intValue() to the result of get(), which won't compile if the ArrayList isn't typed (as you shown it can be). Then it will cast the result to Long, which probably fails too (casting a primitive value to an object, I don't thing autoboxing will work there).
It is better to do: ((Long) temp.get(nth)).intValue(); ie. cast the result of get() to Long (supposing it was what was put there, otherwise (Integer) cast is needed) then get its intValue().
 

This is exactly the sort of thing that I'm struggling to get a firm grasp on. When 'intValue()' was first introduced into the thread, I had no idea what to do with it. I assumed it was a method, but to which class? That I'd didn't know. Explaining the difference the extra parens make in the above example helps me realize that expressions will evaluate to a type (class), and so will have access to the methods of the class even if its not an explicit object variable. Until now, I more or less assumed that one needed a variable of a given class to which to append the .dot methods of that class. In other words, I thought this form:

 <var. name>.<method>

was required, and had no idea this form:

 (<expression that evaluates to type 'class'>).<method in 'class'>


...was even possible. I have seen in the online documentation some examples of complex use of .dot methods, but I don't think I grokked ti 'til now.

BTW, the main hashmap code seems to be working now. I'm now working on the next step, how to make use of the dictionary in my application. I've pasted it here (the Word class is the same as above, so I wont include it now).

1. HashMap words;  // HashMap object
2. String[] tokens;  // Array of all words from input file
3. int counter;
4. void setup() {
5.  
6.   String path = sketchPath+"/data";
7.  
8.   String[] files = listFileNames(path);
9.  
10.   words = new HashMap();
11.   for(int a=0; a<files.length; a++) { // repeat this block for each file in 'files'
12.     String[] lines = loadStrings(files[a]);   // Load file and chop it up
13.     String allText = join(lines, " ");
14.     tokens = splitTokens(allText, " ,.?!:;[]-");
15.  
16.     while(counter<tokens.length) {      // Look at words one at a time
17.       String s = tokens[counter];
18.  
19.       if (words.containsKey(s)) {       // Is the word in the HashMap?
20.         Word w=(Word) words.get(s);
21.         if(w.hasFile(files[a])) {        // if File already in word, then update()
22.           w.updateFile(files[a],counter);
23.         }
24.         else {    //  else add the file to the word with addFile()
25.           w.addFile(files[a],counter);
26.         }
27.       }
28.       else {
29.         Word w = new Word(s, files[a], counter); // Constructed with word, filename, index
30.         words.put(s, w);   
31.       }
32.       counter++;
33.      
34.     } // end of while loop for each word in 'tokens'
35.     counter = 0;
36.   } // End of for loop for each file
37.   // Now we've populated the hashmap, lets see if we can see what's in it
38.   Iterator i = words.keySet().iterator();
39.   while (i.hasNext()) {
40.     String fn = (String) i.next();
41.     Word wd = (Word) words.get(fn);
42.     wd.printWord();
43.   }
44. }