```1   // Example 4.4 joi/examples/TreeMapDemo.java
2   //
3   //
4   // Copyright 2003 Bill Campbell and Ethan Bolker
5
6   import java.util.TreeMap;
7   import java.util.Iterator;
8   import java.util.Set;
9   import java.util.Collection;
10  import java.util.Map;
11
12  // A class illustrating the use of TreeMap.  A typical run:
13  //
14  // %> java TreeMapDemo
15  // Store 3 wrapped ints, keys "one", "two", "three".
16  // The wrapped int stored for "two" is 2
17  //
18  // Iterate over keys, get each value.
19  // Note that key order is aphabetical:
20  // The value for key one is 1
21  // The value for key three is 3
22  // The value for key two is 2
23  //
24  // Iterate over the values:
25  // 1
26  // 3
27  // 2
28  //
29  // Iterate over the key-value pairs:
30  // The value for the entry with key one is 1
31  // The value for the entry with key three is 3
32  // The value for the entry with key two is 2
33  //
34  // How a TreeMap represents itself as a String:
35  // {one=1, three=3, two=2}
36  //
37  // Store a different value at key "two"
38  // {one=1, three=3, two=2222}
39  //
40  // Store map.get( "one" ) at key "two"
41  // {one=1, three=3, two=1}
42  //
43  // A TreeMap with Integer keys mapping to String values
44  // {1=I, 2=II, 3=III}
45  // %>
46
47  public class TreeMapDemo
48  {
49      public static void main( String[] args )
50      {
51          Terminal terminal = new Terminal(); // for input and output
52
53          TreeMap map = new TreeMap();
54
55          // Put in some ints (each wrapped up as an Integer object)
56          terminal.println(
57            "Store 3 wrapped ints, keys \"one\", \"two\", \"three\".");
58          map.put("one",   new Integer(1) );
59          map.put("two",   new Integer(2) );
60          map.put("three", new Integer(3) );
61
62          // get the value associated with a key;
63          // notice the required cast.
64          Integer wrappedInt = (Integer) map.get( "two" );
65
66          // And print the wrapped int
67          terminal.println( "The wrapped int stored for \"two\" is "
68                            + wrappedInt);
69
70
71          // The set of keys.
72          Set keys = map.keySet();
73          // The iterator over this "set" of keys will return
74          // the keys in key-order.
75          terminal.println( "\nIterate over keys, get each value." );
76          terminal.println( "Note that key order is aphabetical:" );
77          Iterator keysIterator = keys.iterator();
78          while ( keysIterator.hasNext() ) {
79              String key = (String) keysIterator.next();
80              terminal.println( "The value for key " + key + " is "
81                                + ((Integer) map.get( key)) );
82          }
83
84          // Iterate over the collection of values;
85          // notice the order is the same (ie the key-order).
86          terminal.println( "\nIterate over the values:" );
87          Iterator valuesIterator = map.values().iterator();
88          while ( valuesIterator.hasNext() ) {
89              terminal.println( ((Integer) valuesIterator.next()));
90          }
91
92          // The set of Map.Entry objects (key-value pairs);
93          // Map.Entry is an inner class of Map.
94
95          // Iterate over the entries.
96          terminal.println( "\nIterate over the key-value pairs:" );
97          Iterator entriesIterator = map.entrySet().iterator();
98          while ( entriesIterator.hasNext() ) {
99              Map.Entry entry = (Map.Entry) entriesIterator.next();
100             terminal.println( "The value for the entry with key "
101                       + entry.getKey() + " is "
102                       + ((Integer) entry.getValue()));
103         }
104
105         // how a TreeMap represents itself as a String:
106         terminal.println(
107             "\nHow a TreeMap represents itself as a String:");
108         terminal.println(map.toString());
109         terminal.println();
110
111         // We can overwrite the value stored under a key
112         terminal.println(
113             "Store a different value at key \"two\"");
114         map.put("two", new Integer(2222));
115         terminal.println(map.toString());
116         terminal.println();
117
118         // We can store the same value under two keys
119         terminal.println(
120             "Store map.get( \"one\" ) at key \"two\"");
121         map.put("two", map.get( "one" ) );
122         terminal.println(map.toString());
123         terminal.println();
124
125         // And keys don't necessarily have to be Strings;
126         // Here's a TreeMap mapping Integers to strings.
127         terminal.println(
128             "A TreeMap with Integer keys mapping to String values");
129         map = new TreeMap();
130         map.put( new Integer( 1 ), "I" );
131         map.put( new Integer( 2 ), "II" );
132         map.put( new Integer( 3 ), "III" );
133         terminal.println(map.toString());
134         terminal.println();
135     }
136 }
137 ```