Chris Rathman / ChrisRath@aol.com

/************************************************************************
 *                                                                      *
 * java.util                                                            *
 *                                                                      *
 *    Interfaces:                                                       *
 *       Enumeration                     Observer                       *
 *       EventListener                                                  *
 *                                                                      *
 *      #Collection                     #Map                            *
 *      #Comparator                     #Map.Entry                      *
 *      #Iterator                       #Set                            *
 *      #List                           #SortedMap                      *
 *      #ListIterator                   #SortedSet                      *
 *                                                                      *
 *    Classes:                                                          *
 *       BitSet                          Properties                     *
 *       Calendar                        PropertyResourceBundle         *
 *       Date                            Random                         *
 *       Dictionary                      ResourceBundle                 *
 *       EventObject                     SimpleTimeZone                 *
 *       GregorianCalendar               Stack                          *
 *       Hashtable                       StringTokenizer                *
 *       ListResourceBundle              TimeZone                       *
 *       Locale                          Vector                         *
 *       Observable                                                     *
 *                                                                      *
 *      #AbstractCollection             #HashMap                        *
 *      #AbstractList                   #HashSet                        *
 *      #AbstractMap                    #LinkedList                     *
 *      #AbstractSequentialList         #PropertyPermission             *
 *      #AbstractSet                    #TreeMap                        *
 *      #ArrayList                      #TreeSet                        *
 *      #Arrays                         #WeakHashMap                    *
 *      #Collections                                                    *
 *                                                                      *
 *    Exceptions:                                                       *
 *       EmptyStackException             NoSuchElementException         *
 *       MissingResourceException        TooManyListenersException      *
 *                                                                      *
 *      #ConcurrentModificationException                                *
 *                                                                      *
 ************************************************************************/
package Test.Chris;
import java.util.*;

public class Java_util {
   public static void main(String[] args) {
      Java_util obj = new Java_util();
      obj.exercise();
      System.exit(0);
   }

   public void exercise() {
      enumeration();
      vector();
      stack();
      bitset();
      hashtable();
      observable();
      random();
      date();

      calendar();
      dictionary();
      eventobject();
      gregoriancalendar();
      locale();
      properties();
      propertyresourcebundle();
      resourcebundle();
      simpletimezone();
      stringtokenizer();
      timezone();
      eventlistener();

      abstractcollection();
      abstractlist();
      abstractmap();
      abstractsequentiallist();
      abstractset();
      arraylist();
      arrays();
      collections();
      hashmap();
      hashset();
      linkedlist();
      propertypermission();
      treemap();
      treeset();
      weakhashmap();

      collection();
      comparator();
      iterator();
      list();
      listiterator();
      map();
      map_entry();
      set();
      sortedmap();
      sortedset();
   }

   class Chris {
      int a = 0;
      Chris(int i) {
         a = i;
      }
   }

   /*********************************************************************
    *                                                                   *
    * Enumeration Interface:                                            *
    *                                                                   *
    *    Desc:    Collection of objects that can be retrieved serially  *
    *                                                                   *
    *    Methods:                                                       *
    *       hasMoreElements      nextElement                            *
    *                                                                   *
    *********************************************************************/
   class ChrisEnumeration implements Enumeration {
      int index = 0;
      String[] sar;

      ChrisEnumeration() {
         sar = new String[3];
         sar[0] = "abc";
         sar[1] = "def";
         sar[2] = "ghi";
      }

      public boolean hasMoreElements() {
         return (index < sar.length);
      }

      public Object nextElement() throws NoSuchElementException {
         if (index >= sar.length) throw new NoSuchElementException();
         return sar[index++];
      }
   }

   void enumeration() {
      String c;
      Enumeration z = new ChrisEnumeration();
      while (z.hasMoreElements()) {     // tests if this enumeration contains more elements
         c = (String)z.nextElement();   // returns the next element of this enumeration
      }
   }

   /*********************************************************************
    *                                                                   *
    * Vector:                                                           *
    *                                                                   *
    *    Desc:    Define collection of objects that acts like an array  *
    *                                                                   *
    *    Methods:                                                       *
    *       addElement           firstElement         removeElementAt   *
    *       capacity             indexOf              setElementAt      *
    *       clone                insertElementAt      setSize           *
    *       contains             isEmpty              size              *
    *       copyInto             lastElement          toString          *
    *       elementAt            lastIndexOf          trimToSize        *
    *       elements             removeAllElements                      *
    *       ensureCapacity       removeElement                          *
    *                                                                   *
    *      #add                 #get                 #removeAll         *
    *      #addAll              #hashCode            #retainAll         *
    *      #clear               #get                 #set               *
    *      #containsAll         #hashCode            #subList           *
    *      #equals              #remove              #toArray           *
    *                                                                   *
    *********************************************************************/
   void vector() {
      int i;
      boolean b;
      String s;
      Chris obj = new Chris(0);

      Vector x = new Vector(10, 5);     // specify initial capacity and incremental allocation

      x.addElement(new Chris(1));       // adds the component to end of vector, increasing its size by one
      x.addElement(new Chris(2));
      x.addElement(new Chris(3));
      x.addElement(new Chris(4));
      x.addElement(new Chris(5));
      x.setElementAt(new Chris(6), 4);  // sets object as a component at specified index
      x.insertElementAt(obj, 2);        // inserts object as a component at specified index

      b = x.isEmpty();                  // tests if this vector has no components
      b = x.contains(obj);              // tests if the specified object is a component in this vector

      obj = (Chris)x.firstElement();    // returns the first component of this vector
      obj = (Chris)x.lastElement();     // returns the last component of the vector
      obj = (Chris)x.elementAt(2);      // returns the component at the specified index
      i = x.indexOf(obj);               // returns index of first occurrence of object
      i = x.indexOf(obj, 2);            // returns index of first occurrence of object starting at index
      i = x.lastIndexOf(obj);           // returns index of last occurrence of object
      i = x.lastIndexOf(obj, 4);        // returns index of last occurrence of object ending at index
      Enumeration z = x.elements();     // returns an enumeration of the components of this vector
      while (z.hasMoreElements()) {
         obj = (Chris)z.nextElement();
      }

      Chris[] pob = new Chris[x.size()];
      x.copyInto(pob);                  // copies the components of this vector into the specified array
      Vector y = (Vector)x.clone();     // returns a clone of this vector

      x.ensureCapacity(15);             // ensure minumum allocated capacity
      i = x.capacity();                 // returns current capacity
      i = x.size();                     // returns the number of components
      x.setSize(5);                     // sets the size of this vector (increase-null or decrease-truncate)
      x.trimToSize();                   // trims the capacity to be the vector's current size
      b = x.removeElement(obj);         // removes first occurrence of the argument from this vector
      x.removeElementAt(2);             // deletes the component at the specified index
      x.removeAllElements();            // removes all components from this vector and sets its size to zero
      s = y.toString();                 // returns a string representation of this vector - fairly useless

   /* TO BE DETERMINED
      void add(int index, Object element) // Inserts the specified element at the specified position in this Vector.
      boolean add(Object o) // Appends the specified element to the end of this Vector.
      boolean addAll(Collection c) // Appends all of the elements in the specified Collection to the end of this Vector, in the order that they are returned by the specified Collection's Iterator.
      boolean addAll(int index, Collection c) // Inserts all of the elements in in the specified Collection into this Vector at the specified position.
      void clear() // Removes all of the elements from this Vector.
      boolean containsAll(Collection c) // Returns true if this Vector contains all of the elements in the specified Collection.
      boolean equals(Object o) // Compares the specified Object with this Vector for equality.
      Object get(int index) // Returns the element at the specified position in this Vector.
      int hashCode() // Returns the hash code value for this Vector.
      Object get(int index) // Returns the element at the specified position in this Vector.
      int hashCode() // Returns the hash code value for this Vector.
      Object remove(int index) // Removes the element at the specified position in this Vector.
      boolean remove(Object o) // Removes the first occurrence of the specified element in this Vector If the Vector does not contain the element, it is unchanged.
      boolean removeAll(Collection c) // Removes from this Vector all of its elements that are contained in the specified Collection.
      boolean retainAll(Collection c) // Retains only the elements in this Vector that are contained in the specified Collection.
      Object set(int index, Object element) // Replaces the element at the specified position in this Vector with the specified element.
      List subList(int fromIndex, int toIndex) // Returns a view of the portion of this List between fromIndex, inclusive, and toIndex, exclusive.
      Object[] toArray() // Returns an array containing all of the elements in this Vector in the correct order.
      Object[] toArray(Object[] a) // Returns an array containing all of the elements in this Vector in the correct order.
   */

   }

   /*********************************************************************
    *                                                                   *
    * Stack:                                                            *
    *                                                                   *
    *    Desc:    Define collection of objects that acts like a stack   *
    *                                                                   *
    *    Methods:                                                       *
    *       empty                pop                  search            *
    *       peek                 push                                   *
    *                                                                   *
    *********************************************************************/
   void stack() {
      int i;
      boolean b;
      String s;
      Chris obj = new Chris(0);

      Stack x = new Stack();            // default constructor - initial capacity = 10
      x.push(new Chris(1));             // pushes an item onto the top of this stack
      b = x.empty();                    // tests if this stack is empty
      i = x.search(obj);                // returns where an object is on this stack
      obj = (Chris)x.peek();            // looks at the object at the top of stack without removing it
      obj = (Chris)x.pop();             // removes object at top of stack

      // stack is derived from Vector and has all it's methods available
      x.addElement(new Chris(1));       // adds the component to end of vector, increasing its size by one
      x.addElement(new Chris(2));
      x.addElement(new Chris(3));
      x.addElement(new Chris(4));
      x.addElement(new Chris(5));
      x.setElementAt(new Chris(6), 4);  // sets object as a component at specified index
      x.insertElementAt(obj, 2);        // inserts object as a component at specified index

      b = x.isEmpty();                  // tests if this vector has no components
      b = x.contains(obj);              // tests if the specified object is a component in this vector

      obj = (Chris)x.firstElement();    // returns the first component of this vector
      obj = (Chris)x.lastElement();     // returns the last component of the vector
      obj = (Chris)x.elementAt(2);      // returns the component at the specified index
      i = x.indexOf(obj);               // returns index of first occurrence of object
      i = x.indexOf(obj, 2);            // returns index of first occurrence of object starting at index
      i = x.lastIndexOf(obj);           // returns index of last occurrence of object
      i = x.lastIndexOf(obj, 4);        // returns index of last occurrence of object ending at index
      Enumeration z = x.elements();     // returns an enumeration of the components of this vector
      while (z.hasMoreElements()) {
         obj = (Chris)z.nextElement();
      }

      Chris[] pob = new Chris[x.size()];
      x.copyInto(pob);                  // copies the components of this vector into the specified array
      Stack y = (Stack)x.clone();       // returns a clone of this vector

      x.ensureCapacity(15);             // ensure minumum allocated capacity
      i = x.capacity();                 // returns current capacity
      i = x.size();                     // returns the number of components
      x.setSize(5);                     // sets the size of this vector (increase-null or decrease-truncate)
      x.trimToSize();                   // trims the capacity to be the vector's current size
      b = x.removeElement(obj);         // removes first occurrence of the argument from this vector
      x.removeElementAt(2);             // deletes the component at the specified index
      x.removeAllElements();            // removes all components from this vector and sets its size to zero

      s = y.toString();                 // returns a string representation of this vector - fairly useless
   }

   /*********************************************************************
    *                                                                   *
    * BitSet:                                                           *
    *                                                                   *
    *    Desc:    Vector of bits (boolean) in 64 bit chunks             *
    *                                                                   *
    *    Methods:                                                       *
    *       and                  get                  size              *
    *       clear                hashCode             toString          *
    *       clone                or                   xor               *
    *       equals               set                                    *
    *                                                                   *
    *      #andNot              #length                                 *
    *                                                                   *
    *********************************************************************/
   void bitset() {
      int i;
      boolean b;
      String s;
      BitSet x = new BitSet();
      BitSet y = new BitSet();

      for (i = 0; i < 32; i++) x.clear(i);
      for (i = 0; i < 32; i++) y.set(i);

      x.set(0);                         // sets a bit
      x.clear(1);                       // clears a bit
      x.and(y);                         // logically ANDs this bit set with the specified set of bits
      x.or(y);                          // logically ORs this bit set with the specified set of bits
      x.xor(y);                         // logically XORs this bit set with the specified set of bits

      b = x.get(0);                     // gets a bit
      i = x.size();                     // calculates and returns the set's size in bits
      s = x.toString();                 // converts the BitSet to a String

      x = (BitSet)y.clone();            // clones the BitSet
      b = x.equals(y);                  // compares this object against the specified object
      i = x.hashCode();                 // gets the hashcode

   /* TO BE DETERMINED
      void andNot(BitSet set) // Clears all of the bits in this BitSet whose corresponding bit is set in the specified BitSet
      int length() // Returns the "logical size" of this BitSet: the index of the highest set bit in the BitSet plus one
   */
   }

   /*********************************************************************
    *                                                                   *
    * HashTable:                                                        *
    *                                                                   *
    *    Desc:    Define collection of objects - retrieved by key       *
    *                                                                   *
    *    Methods:                                                       *
    *       clear                elements             put               *
    *       clone                get                  remove            *
    *       contains             isEmpty              size              *
    *       containsKey          keys                 toString          *
    *                                                                   *
    *      #containsValue       #hashCode             #putAll           *
    *      #entrySet            #keySet               #values           *
    *      #equals                                                      *
    *                                                                   *
    *********************************************************************/
   void hashtable() {
      int i;
      boolean b;
      String s;
      Chris obj = new Chris(1);
      Chris nob;

      Hashtable x = new Hashtable(10, 0.75F);    // specify initial capacity and load factor

      nob = (Chris)x.put("A", obj);     // maps the specified key to the specified value in hashtable
      nob = (Chris)x.put("B", new Chris(2));
      nob = (Chris)x.put("C", new Chris(3));
      nob = (Chris)x.put("D", new Chris(4));

      i = x.size();                     // returns the number of keys in this hashtable
      b = x.isEmpty();                  // tests if this hashtable maps no keys to values
      b = x.contains(obj);              // tests if some key maps into specified value in hashtable
      b = x.containsKey("A");           // tests if some key maps into specified value in hashtable

      Hashtable y = (Hashtable)x.clone();  // returns a clone of this hashtable

      obj = (Chris)x.get("B");          // returns value which key is mapped in this hashtable

      Enumeration z = x.elements();     // returns an enumeration of the values in this hashtable
      while (z.hasMoreElements()) {
         obj = (Chris)z.nextElement();
      }
      z = x.keys();                     // returns an enumeration of the keys in this hashtable
      while (z.hasMoreElements()) {
         s = (String)z.nextElement();
         obj = (Chris)x.get(s);
      }

      obj = (Chris)x.remove(obj);       // removes the key (and its corresponding value) from this hashtable
      x.clear();                        // clears this hashtable so that it contains no keys

      s = y.toString();                 // returns a string representation of this vector - fairly useless

   /* TO BE DETERMINED
      boolean containsValue(Object value) // Returns true if this Hashtable maps one or more keys to this value. Note that this method is identical in functionality to contains (which predates the Map interface).
      Set entrySet() // Returns a Set view of the entries contained in this Hashtable.
      boolean equals(Object o) // Compares the specified Object with this Map for equality, as per the definition in the Map interface.
      int hashCode() // Returns the hash code value for this Map as per the definition in the Map interface.
      Set keySet() // Returns a Set view of the keys contained in this Hashtable.
      void putAll(Map t) // Copies all of the mappings from the specified Map to this Hashtable These mappings will replace any mappings that this Hashtable had for any of the keys currently in the specified Map.
      Collection values() // Returns a Collection view of the values contained in this Hashtable.
   */
   }

   /*********************************************************************
    *                                                                   *
    * Dictionary:                                                       *
    *                                                                   *
    *    Desc:    abstract class used for hashtable                     *
    *                                                                   *
    *    Methods:                                                       *
    *       elements             keys                 size              *
    *       get                  put                                    *
    *       isEmpty              remove                                 *
    *                                                                   *
    *********************************************************************/
   void dictionary() {
   /* TO BE DETERMINED
      elements()                        // returns an enumeration of the values in this dictionary
      get(Object)                       // returns the value to which the key is mapped in this dictionary
      isEmpty()                         // tests if this dictionary maps no keys to value
      keys()                            // returns an enumeration of the keys in this dictionary
      put(Object, Object)               // maps the specified key to the specified value in this dictionary
      remove(Object)                    // removes the key (and its corresponding value) from this dictionary
      size()                            // returns the number of keys in this dictionary
   */
   }

   /*********************************************************************
    *                                                                   *
    * Observer Interface:                                               *
    *                                                                   *
    *    Desc:    Detect change in observable class via update method   *
    *                                                                   *
    *    Methods:                                                       *
    *       update                                                      *
    *                                                                   *
    *********************************************************************/
   class ChrisObserver implements Observer {
      String name;

      public ChrisObserver(String name) {
         this.name = name;
      }

      // this method is called whenever the observed object is changed
      public void update(Observable obs, Object obj) {
         if (obj == null) {
            // System.out.println(name + " Update = " + ((ChrisObservable)obs).myName());
         } else {
            // System.out.println(name + " Update = " + ((ChrisObservable)obs).myName() + " " + (String)obj);
         }
      }
   }

   /*********************************************************************
    *                                                                   *
    * Observable:                                                       *
    *                                                                   *
    *    Desc:    Communicate change in class object to other classes   *
    *                                                                   *
    *    Methods:                                                       *
    *       addObserver          deleteObserver       notifyObservers   *
    *       clearChanged         deleteObservers      setChanged        *
    *       countObservers       hasChanged                             *
    *                                                                   *
    *********************************************************************/
   class ChrisObservable extends Observable {
      public String name = "Chris";

      public void nameMe(String name) {
         this.name = name;
      }

      public void changeMe() {
         setChanged();                  // indicates that this object has changed
      }

      public void unchangeMe() {
         clearChanged();                // clear changed flag
      }

      public String myName() {
         return name;
      }
   }

   void observable() {
      int i;
      boolean b;

      ChrisObservable Chris = new ChrisObservable();
      ChrisObserver Fred = new ChrisObserver("Fred");
      ChrisObserver Hank = new ChrisObserver("Hank");
      ChrisObserver Pete = new ChrisObserver("Pete");

      Chris.addObserver(Fred);          // adds an observer to the set of observers for this object
      Chris.addObserver(Hank);
      Chris.addObserver(Pete);
      Chris.nameMe("Critter");
      Chris.changeMe();
      i = Chris.countObservers();       // returns the number of observers of this object
      b = Chris.hasChanged();           // tests if this object has changed
      Chris.notifyObservers();          // if changed, notify observers and call clearChanged
      Chris.nameMe("Cris");
      Chris.changeMe();
      Chris.notifyObservers("Hello");   // if changed, notify observers with object and call clearChanged
      Chris.nameMe("Cris");
      Chris.changeMe();
      Chris.unchangeMe();
      Chris.deleteObserver(Fred);       // deletes an observer from the set of observers of this object
      Chris.deleteObservers();          // clears the observer list
   }

   /*********************************************************************
    *                                                                   *
    * Random:                                                           *
    *                                                                   *
    *    Desc:    Deterministic random number generator                 *
    *                                                                   *
    *    Methods:                                                       *
    *       next                 nextFloat            nextLong          *
    *       nextBytes            nextGaussian         setSeed           *
    *       nextDouble           nextInt                                *
    *                                                                   *
    *      #nextBoolean                                                 *
    *                                                                   *
    *********************************************************************/
   void random() {
      int i;
      long n;
      float f;
      double d;
      byte[] bx = new byte[10];
      boolean b;

      Random x = new Random(997L);

      x.setSeed(997L);                  // sets seed of random number generator using a single long seed
      i = x.nextInt();                  // returns the next pseudorandom as int value (-2^32 - 2^32-1)
      n = x.nextLong();                 // returns the next pseudorandom as long value (-2^64 - 2^64-1)
      f = x.nextFloat();                // returns the next pseudorandom as float value (0.0 - 1.0)
      d = x.nextDouble();               // returns the next pseudorandom as double value (0.0 - 1.0)
      d = x.nextGaussian();             // gaussian distributed double value (mean=0.0 sdev=1.0)
      x.nextBytes(bx);                  // generates a user specified number of random bytes (-2^8 - 2^8-1)
      b = x.nextBoolean();              // returns the next pseudorandom as boolean value (true - false)
   }

   /*********************************************************************
    *                                                                   *
    * Date:                                                             *
    *                                                                   *
    *    Desc:    encapsulates a point in time - specific date/time     *
    *                                                                   *
    *    Methods:                                                       *
    *                                                                   *
    *      %getDate             %getTimezoneOffset   %setMonth          *
    *      %getDay              %getYear             %setSeconds        *
    *      %getHours            %parse               %setYear           *
    *      %getMinutes          %setDate             %toGMTString       *
    *      %getMonth            %setHours            %toLocaleString    *
    *      %getSeconds          %setMinutes          %UTC               *
    *                                                                   *
    *       after                getTime              setTime           *
    *       before               hashCode             toString          *
    *       equals                                                      *
    *                                                                   *
    *      #clone               #compareTo                              *
    *                                                                   *
    *********************************************************************/
   void date() {
      boolean b;

      Date x = new Date();              // current date/time
      Date y = new Date(1000L*60*60*24);// date/time in milliseconds relative to 1/1/1970

      b = x.after(y);                   // tests if this date is after the specified date
      b = x.before(y);                  // tests if this date is before the specified date
      b = x.equals(y);                  // compares two dates
      y.setTime(1000L*60*60*24*365);    // sets to specified number of milliseconds since 1/1/1970
      long n = y.getTime();             // number of milliseconds since 1//1/1970 GMT

      int i = y.hashCode();             // computes a hashcode for the object
      String s = y.toString();          // creates a canonical string representation of the date

   /* TO BE DETERMINED
      Object clone() // Return a copy of this object.
      int compareTo(Date anotherDate) // Compares two Dates for ordering.
      int compareTo(Object o) // Compares this Date to another Object.
   */
   }

   /*********************************************************************
    *                                                                   *
    * GregorianCalendar:                             (extends Calendar) *
    *                                                                   *
    *    Desc:    x                                                     *
    *                                                                   *
    *    Vars:                                                          *
    *       AD                   BC                                     *
    *                                                                   *
    *    Methods:                                                       *
    *       add                  getGregorianChange   isLeapYear        *
    *       after                getLeastMaximum      roll              *
    *       before               getMaximum           setGregorianChange*
    *       equals               getMinimum                             *
    *       getGreatestMinimum   hashCode                               *
    *                                                                   *
    *      #getActualMaximum    #getActualMinimum                       *
    *                                                                   *
    *********************************************************************/
   void gregoriancalendar() {
      int i;
      boolean f;
      Date d;
      GregorianCalendar x;
      GregorianCalendar y;

      x = new GregorianCalendar();      // current date/time
      y = new GregorianCalendar(1998, Calendar.JULY, 1, 11, 20);

      f = x.isLeapYear(1996);           // determines if the given year is a leap year
      f = x.after(y);                   // compares the time field records
      f = x.before(y);                  // compares the time field records
      f = x.equals(y);                  // compares this calendar to the specified object

      y.add(Calendar.DATE, 4);          // overrides Calendar Date Arithmetic function
      y.roll(Calendar.DATE, true);      // field rolling function - true=rollup; false=rolldown

      i = y.getMinimum(Calendar.MINUTE);       // returns minimum value for the given field
      i = y.getMaximum(Calendar.MONTH);        // returns maximum value for the given field
      i = y.getLeastMaximum(Calendar.YEAR);    // returns lowest maximum value for the given field if varies
      i = y.getGreatestMinimum(Calendar.HOUR); // returns highest minimum value for the given field if varies
      d = y.getGregorianChange();       // gets the Gregorian Calendar change date (switch from Julian)

      i = x.hashCode();                 // override hashCode

   /* TO BE DETERMINED
      AD                                // useful constant for GregorianCalendar
      BC                                // useful constant for GregorianCalendar
      int getActualMaximum(int field)   // Return the maximum value that this field could have, given the current date.
      int getActualMinimum(int field)   // Return the minimum value that this field could have, given the current date.
   */
   }

   /*********************************************************************
    *                                                                   *
    * Calendar:                                              (abstract) *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Vars:                                                          *
    *       AM                     FRIDAY             PM                *
    *       AM_PM                  HOUR               SATURDAY          *
    *       APRIL                  HOUR_OF_DAY        SECOND            *
    *       AUGUST                 JANUARY            SEPTEMBER         *
    *       DATE                   JULY               SUNDAY            *
    *       DAY_OF_MONTH           JUNE               THURSDAY          *
    *       DAY_OF_WEEK            MARCH              TUESDAY           *
    *       DAY_OF_WEEK_IN_MONTH   MAY                UNDECIMBER        *
    *       DAY_OF_YEAR            MILLISECOND        WEDNESDAY         *
    *       DECEMBER               MINUTE             WEEK_OF_MONTH     *
    *       DST_OFFSET             MONDAY             WEEK_OF_YEAR      *
    *       ERA                    MONTH              YEAR              *
    *       FEBRUARY               NOVEMBER           ZONE_OFFSET       *
    *       FIELD_COUNT            OCTOBER                              *
    *                                                                   *
    *    Methods:                                                       *
    *           add                          getMinimum                 *
    *           after                        getTime                    *
    *           before                       getTimeZone                *
    *           clear                        isLenient                  *
    *           clone                        isSet                      *
    *           equals                       roll                       *
    *           get                          set                        *
    *           getAvailableLocales          setFirstDayOfWeek          *
    *           getFirstDayOfWeek            setLenientWeek             *
    *           getGreatestMinimum           setMinimalDaysInFirstWeek  *
    *           getInstance                  setTime                    *
    *           getLeastMaximum              setTimeZone                *
    *           getMaximum                   toString                   *
    *           getMinimalDaysInFirst                                   *
    *                                                                   *
    *          #getActualMaximum            #hashcode                   *
    *          #getActualMinimum                                        *
    *                                                                   *
    *********************************************************************/
   void calendar() {
      int i;
      boolean f;
      String s = "";
      Locale[] z;
      Calendar x = new GregorianCalendar();
      Calendar y = new GregorianCalendar(1998, Calendar.JULY, 1, 11, 20, 5);

      TimeZone tz = x.getTimeZone();    // gets the time zone
      tz = TimeZone.getTimeZone("CST");
      x.setTimeZone(tz);                // sets the time zone with the given time zone value
      z = x.getAvailableLocales();      // gets the set of locales for which Calendars are installed
      for (i = 0; i < z.length; i++) {
         s = z[i].getDisplayName();
      }

      y.set(1998, x.JULY, 1, 11, 20, 5);// sets fields yyyy, mm, dd, hh, mm, ss
      y = Calendar.getInstance();       // gets a Calendar using the default timezone and locale
      Date d = x.getTime();             // gets this Calendar's current time
      x.setTime(d);                     // sets this Calendar's current time with the given Date

      i = x.get(x.YEAR);                // Gets the value for a given time field
      i = x.get(x.MONTH);
      i = x.get(x.WEEK_OF_YEAR);
      i = x.get(x.WEEK_OF_MONTH);
      i = x.get(x.DAY_OF_YEAR);
      i = x.get(x.DAY_OF_MONTH);
      i = x.get(x.DAY_OF_WEEK);
      i = x.get(x.DAY_OF_WEEK_IN_MONTH);
      i = x.get(x.HOUR);
      i = x.get(x.HOUR_OF_DAY);
      i = x.get(x.MINUTE);
      i = x.get(x.SECOND);
      i = x.get(x.MILLISECOND);

      switch (x.get(x.DAY_OF_WEEK)) {
         case x.SUNDAY:    s = "Sun";  break;
         case x.MONDAY:    s = "Mon";  break;
         case x.TUESDAY:   s = "Tue";  break;
         case x.WEDNESDAY: s = "Wed";  break;
         case x.THURSDAY:  s = "Thu";  break;
         case x.FRIDAY:    s = "Fri";  break;
         case x.SATURDAY:  s = "Sat";  break;
      }

      switch (x.get(x.MONTH)) {
         case x.JANUARY:   s = "Jan";  break;
         case x.FEBRUARY:  s = "Feb";  break;
         case x.MARCH:     s = "Mar";  break;
         case x.APRIL:     s = "Apr";  break;
         case x.MAY:       s = "May";  break;
         case x.JUNE:      s = "Jun";  break;
         case x.JULY:      s = "Jul";  break;
         case x.AUGUST:    s = "Aug";  break;
         case x.SEPTEMBER: s = "Sep";  break;
         case x.OCTOBER:   s = "Oct";  break;
         case x.NOVEMBER:  s = "Nov";  break;
         case x.DECEMBER:  s = "Dec";  break;
      }

      i = x.getFirstDayOfWeek();        // gets what the first day of the week is
      i = x.getMinimum(x.MINUTE);       // returns minimum value for the given field
      i = x.getMaximum(x.MONTH);        // returns maximum value for the given field
      i = x.getLeastMaximum(x.YEAR);    // returns lowest maximum value for the given field if varies
      i = x.getGreatestMinimum(x.HOUR); // returns highest minimum value for the given field if varies
      i = x.getMinimalDaysInFirstWeek();// minimal days required in the first week of the year

      x.add(Calendar.DATE, 4);          // date Arithmetic function
      x.roll(Calendar.DATE, true);      // field rolling function - true=rollup; false=rolldown
      y.clear();                        // clears the values of all the time fields
      x.clear(x.MILLISECOND);           // clears the value in the given time field
      x.setFirstDayOfWeek(x.SUNDAY);    // sets what the first day of the week is
      x.setLenient(false);              // specify whether or not date/time interpretation is to be lenient
      x.setMinimalDaysInFirstWeek(1);   // minimal days required in the first week of the year

      f = x.after(y);                   // compares the time field records
      f = x.before(y);                  // compares the time field records
      f = x.isLenient();                // tell whether date/time interpretation is to be lenient
      f = x.isSet(x.MONTH);             // determines if the given time field has a value set
      f = x.equals(y);                  // compares this calendar to the specified object

      y = (Calendar)x.clone();          // overrides Cloneable
      s = x.toString();                 // return a string representation of this calendar

   /* TO BE DETERMINED
      AM                                // useful constant for hour in 12-hour clock
      AM_PM                             // useful constant for date and time
      DATE                              // useful constant for date and time
      DST_OFFSET                        // useful constant for date and time
      ERA                               // useful constant for date and time
      FIELD_COUNT                       // useful constant for date and time
      PM                                // useful constant for hour in 12-hour clock
      UNDECIMBER                        // useful constant for month
      ZONE_OFFSET                       // useful constant for date and time

      int getActualMaximum(int field)   // Return the maximum value that this field could have, given the current date.
      int getActualMinimum(int field)   // Return the minimum value that this field could have, given the current date.
      int hashCode()                    // Returns a hash code for this calendar.
   */
   }

   /*********************************************************************
    *                                                                   *
    * TimeZone:                                                         *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Fields:                                                        *
    *       LONG                 SHORT                                  *
    *                                                                   *
    *    Methods:                                                       *
    *       clone                getOffset            setDefault        *
    *       getAvailableIDs      getRawOffset         setID             *
    *       getDefault           getTimeZone          setRawOffset      *
    *       getID                inDaylightTime       useDaylightTime   *
    *                                                                   *
    *      #getDisplayName      #hasSameRules                           *
    *                                                                   *
    *********************************************************************/
   void timezone() {
      int i;
      boolean f;
      String s;
      String[] sx;
      Date d = new Date();
      GregorianCalendar c = new GregorianCalendar();
      TimeZone tz;
      TimeZone ty;

      tz = TimeZone.getTimeZone("CST"); // gets the TimeZone for the given ID
      tz = TimeZone.getDefault();       // gets the default TimeZone for this host
      TimeZone.setDefault(tz);          // sets time zone to using the given TimeZone
      ty = (TimeZone)tz.clone();        // overrides Cloneable

      f = tz.useDaylightTime();         // queries if this time zone uses Daylight Savings Time
      f = tz.inDaylightTime(d);         // queries if the given date is in Daylight Savings Time in time zone

      s = tz.getID();                   // gets the ID of this time zone
      tz.setID(s);                      // sets the time zone ID
      sx = TimeZone.getAvailableIDs();  // gets all the available IDs supported
      i = tz.getRawOffset();            // gets unmodified offset, NOT modified in case of daylight savings
      tz.setRawOffset(i);               // sets the base time zone offset to GMT
      sx = TimeZone.getAvailableIDs(i); // gets the available IDs according to the given time zone offset
      i = tz.getOffset(GregorianCalendar.AD, 1960, 7, 1, 3, 0); // gets the time zone offset for current date

   /* TO BE DETERMINED
      static int LONG  // A style specifier for getDisplayName() indicating a long name, such as "Pacific Standard Time."
      static int SHORT // A style specifier for getDisplayName() indicating a short name, such as "PST."

      String getDisplayName() // Returns a name of this time zone suitable for presentation to the user in the default locale.
      String getDisplayName(boolean daylight, int style) // Returns a name of this time zone suitable for presentation to the user in the default locale.
      String getDisplayName(boolean daylight, int style, Locale locale) // Returns a name of this time zone suitable for presentation to the user in the specified locale.
      String getDisplayName(Locale locale) // Returns a name of this time zone suitable for presentation to the user in the specified locale.
      boolean hasSameRules(TimeZone other) // Returns true if this zone has the same rule and offset as another zone.
   */
   }

   /*********************************************************************
    *                                                                   *
    * SimpleTimeZone:                                                   *
    *                                                                   *
    *    Desc:    TimeZone for use with GregorianCalendar               *
    *                                                                   *
    *    Methods:                                                       *
    *       clone                hashCode             setStartRule      *
    *       equals               inDaylightTime       setStartYear      *
    *       getOffset            setEndRule           toString          *
    *       getRawOffset         setRawOffset         useDaylightTime   *
    *                                                                   *
    *      #getDSTSavings       #hasSameRules        #setDSTSavings     *
    *                                                                   *
    *********************************************************************/
   void simpletimezone() {
      int i;
      boolean f;
      String s;
      Date d = new Date();
      TimeZone tz = TimeZone.getDefault();
      SimpleTimeZone ty;
      SimpleTimeZone ts = new SimpleTimeZone(tz.getRawOffset(), "CST");

      i = ts.getRawOffset();            // gets the GMT offset for this time zone
      ts.setRawOffset(i);               // sets the base time zone offset to GMT
      i = ts.getOffset(GregorianCalendar.AD, 1960, 7, 1, 3, 0); // gets the time zone offset for current date

      f = ts.inDaylightTime(d);         // queries if the given date is in Daylight Savings Time
      f = ts.useDaylightTime();         // queries if this time zone uses Daylight Savings Time

      ts.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2*60*60*1000);   // daylight savings starting rule
      ts.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*60*60*1000);  // daylight savings ending rule
      ts.setStartYear(1968);            // sets the daylight savings starting year

      ty = (SimpleTimeZone)ts.clone();  // overrides Cloneable
      f = ts.equals(ty);                // compares the equality of two SimpleTimeZone objects
      i = ts.hashCode();                // override hashCode
      s = ts.toString();                // return a string representation of this time zone

   /* TO BE DETERMINED
      int getDSTSavings() // Returns the amount of time in ms that the clock is advanced during DST
      boolean hasSameRules(TimeZone other) // Return true if this zone has the same rules and offset as another zone.
      void setDSTSavings(int millisSavedDuringDST) // Sets the amount of time in ms that the clock is advanced during DST.
   */
   }

   /*********************************************************************
    *                                                                   *
    * Locale:                                                           *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Vars:                                                          *
    *       CANADA               GERMAN             KOREAN              *
    *       CANADA_FRENCH        GERMANY            PRC                 *
    *       CHINA                ITALIAN            SIMPLIFIED_CHINESE  *
    *       CHINESE              ITALY              TAIWAN              *
    *       ENGLISH              JAPAN              TRADITIONAL_CHINESE *
    *       FRANCE               JAPANESE           UK                  *
    *       FRENCH               KOREA              US                  *
    *                                                                   *
    *    Methods:                                                       *
    *       clone                getDisplayLanguage   getLanguage       *
    *       equals               getDisplayName       getVariant        *
    *       getCountry           getDisplayVariant    hashCode          *
    *       getDefault           getISO3Country       setDefault        *
    *       getDisplayCountry    getISO3Language      toString          *
    *                                                                   *
    *      #getAvailableLocales #getISOCountries     #getISOLanguages   *
    *                                                                   *
    *********************************************************************/
   void locale() {
      int i;
      boolean f;
      String s;
      Locale x = new Locale("EN", "US");
      Locale y = Locale.getDefault();   // common method of getting the current default Locale

      Locale.setDefault(Locale.US);     // sets the default

      s = x.getCountry();               // two-letter ISO-3166 country code
      s = x.getISO3Country();           // three-letter ISO country abbreviation of the locale
      s = x.getDisplayCountry();        // name for the locale's country
      s = x.getDisplayLanguage();       // name for the locale's language
      s = x.getDisplayName();           // name for the locale
      s = x.getDisplayVariant();        // name for the locale's variant code
      s = x.getISO3Language();          // three-letter ISO language abbreviation of the locale
      s = x.getLanguage();              // name of field, an lowercased two-letter ISO-639 code
      s = x.getVariant();               // name of field

      s = x.getDisplayCountry(Locale.US);
      s = x.getDisplayLanguage(Locale.US);
      s = x.getDisplayName(Locale.US);
      s = x.getDisplayVariant(Locale.US);

      x = Locale.CANADA;
      x = Locale.CANADA_FRENCH;
      x = Locale.CHINA;
      x = Locale.CHINESE;
      x = Locale.ENGLISH;
      x = Locale.FRANCE;
      x = Locale.FRENCH;
      x = Locale.GERMAN;
      x = Locale.GERMANY;
      x = Locale.ITALIAN;
      x = Locale.ITALY;
      x = Locale.JAPAN;
      x = Locale.JAPANESE;
      x = Locale.KOREA;
      x = Locale.KOREAN;
      x = Locale.PRC;
      x = Locale.SIMPLIFIED_CHINESE;
      x = Locale.TAIWAN;
      x = Locale.TRADITIONAL_CHINESE;
      x = Locale.UK;
      x = Locale.US;

      y = (Locale)x.clone();            // overrides Cloneable
      f = x.equals(y);                  // compares two Objects for equality
      i = x.hashCode();                 // override hashCode
      s = x.toString();                 // name of the entire locale

   /* TO BE DETERMINED
      static Locale[] getAvailableLocales() // Returns a list of all installed locales.
      static String[] getISOCountries()  // Returns a list of all 2-letter country codes defined in ISO 3166.
      static String[] getISOLanguages() // Returns a list of all 2-letter language codes defined in ISO 639.
   */
   }

   /*********************************************************************
    *                                                                   *
    * EventObject:                                                      *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Vars:                                                          *
    *       source                                                      *
    *                                                                   *
    *    Methods:                                                       *
    *       getSource            toString                               *
    *                                                                   *
    *********************************************************************/
   void eventobject() {
   /* TO BE DETERMINED
      source

      getSource()
      toString()                        // Returns a string representation of the object
   */
   }

   /*********************************************************************
    *                                                                   *
    * EventListener Interface:                                          *
    *                                                                   *
    *    Desc:    x                                                     *
    *                                                                   *
    *********************************************************************/
   void eventlistener() {
   }

   /*********************************************************************
    *                                                                   *
    * Properties:                                                       *
    *                                                                   *
    *    Desc:    hashtable used to store/retrive environment variables *
    *                                                                   *
    *    Methods:                                                       *
    *       getProperty          load                %save              *
    *       list                 propertyNames                          *
    *                                                                   *
    *      #setProperty         #store                                  *
    *                                                                   *
    *********************************************************************/
   void properties() {
      String s;
      Enumeration z;
      Properties p = new Properties();
      Properties d = new Properties(p); // specify second table for defaults

      p.put("myApp.x", "100");
      p.put("myApp.y", "200");
      d.put("myApp.a", "50");

      s = p.getProperty("myApp.x");     // searches for the property with the specified key
      s = p.getProperty("myApp.z", "0");// searches for the property with the specified key - with default

      z = d.propertyNames();            // enumeration of keys in this property list and default property list
      while (z.hasMoreElements()) {
         s = (String)z.nextElement();
      }

      p = System.getProperties();       // returns system properties list

      // p.list(System.out);            // prints this property list out to the specified output stream
      // p.save(System.out, "Properties"); // stores this property list to the specified output stream

   /* TO BE DETERMINED
      load(InputStream)                 // reads a property list from an input stream
      Object setProperty(String key, String value) // Calls the hashtable method put.
      void store(OutputStream out, String header)  // Writes this property list (key and element pairs) in this Properties table to the output stream in a format suitable for loading into a Properties table using the load method.
   */
   }

   /*********************************************************************
    *                                                                   *
    * StringTokenizer:                                                  *
    *                                                                   *
    *    Desc:    parse string into smaller strings (tokens)            *
    *                                                                   *
    *    Methods:                                                       *
    *       countTokens          hasMoreTokens        nextToken         *
    *       hasMoreElements      nextElement                            *
    *                                                                   *
    *********************************************************************/
   void stringtokenizer() {
      int i;
      String s;
      boolean f;

      StringTokenizer x = new StringTokenizer("Hello, my name is Chris!");
      i = x.countTokens();              // calculates number of tokens
      while (x.hasMoreTokens()) {       // tests if more tokens available from this tokenizer's string
         s = x.nextToken();             // next token from this string tokenizer
      }
      f = x.hasMoreElements();          // same value as the hasMoreTokens method

   /* TO BE DETERMINED
      nextElement()                     // Returns the same value as the nextToken method, except that its declared return value is Object rather than String
      nextToken(String)                 // Returns the next token in this string tokenizer's string
   */
   }

   /*********************************************************************
    *                                                                   *
    * ResourceBundle:                                                   *
    *                                                                   *
    *    Desc:    x                                                     *
    *                                                                   *
    *    Methods:                                                       *
    *       getBundle            getObject            getStringArray    *
    *       getKeys              getString            setParent         *
    *                                                                   *
    *      #getLocale                                                   *
    *                                                                   *
    *********************************************************************/
   void resourcebundle() {
      String s;
      Enumeration z;
      ResourceBundle x;

      x = ResourceBundle.getBundle("Test.Chris.Java_util_ResourceBundle_Message", Locale.ITALY);
      s = x.getString("HelloMessage");  // Get an object from a ResourceBundle

      x = ResourceBundle.getBundle("Test.Chris.Java_util_ResourceBundle_Message", Locale.US);
      s = x.getString("HelloMessage");

      s = (String)x.getObject("OtherMessage");     // get an object from a ResourceBundle

      z = x.getKeys();                  // return an enumeration of the keys
      while (z.hasMoreElements()) {
         s = (String)z.nextElement();
      }

   /* TO BE DETERMINED
      getStringArray(String)            // Get an object from a ResourceBundle
      Locale getLocale()                // Return the Locale for this ResourceBundle.
   */
   }

   /*********************************************************************
    *                                                                   *
    * PropertyResourceBundle:                                           *
    *                                                                   *
    *    Desc:    x                                                     *
    *                                                                   *
    *    Methods:                                                       *
    *       getKeys              handleGetObject                        *
    *                                                                   *
    *********************************************************************/
   void propertyresourcebundle () {
   /* TO BE DETERMINED
      getKeys()                         // Implementation of ResourceBundle.getKeys
      handleGetObject(String)           // Override of ResourceBundle, same semantics
   */
   }

   /*********************************************************************
    *                                                                   *
    * #AbstractCollection:                                              *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      addAll
      clear
      contains
      containsAll
      isEmpty
      iterator
      remove
      removeAll
      retainAll
      size
      toArray
      toArray
      toString
    *                                                                   *
    *********************************************************************/
   void abstractcollection() {
   /* TO BE DETERMINED
      boolean add(Object o) // Ensures that this collection contains the specified element (optional operation).
      boolean addAll(Collection c) // Adds all of the elements in the specified collection to this collection (optional operation).
      void clear() // Removes all of the elements from this collection (optional operation).
      boolean contains(Object o) // Returns true if this collection contains the specified element.
      boolean containsAll(Collection c) // Returns true if this collection contains all of the elements in the specified collection.
      boolean isEmpty() // Returns true if this collection contains no elements. This implementation returns size() == 0.
      abstract  Iterator iterator() // Returns an iterator over the elements contained in this collection.
      boolean remove(Object o) // Removes a single instance of the specified element from this collection, if it is present (optional operation).
      boolean removeAll(Collection c) // Removes from this collection all of its elements that are contained in the specified collection (optional operation).
      boolean retainAll(Collection c) // Retains only the elements in this collection that are contained in the specified collection (optional operation).
      abstract  int size() // Returns the number of elements in this collection.
      Object[] toArray() // Returns an array containing all of the elements in this collection.
      Object[] toArray(Object[] a) // Returns an array with a runtime type is that of the specified array and that contains all of the elements in this collection.
      String toString() // Returns a string representation of this collection.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #AbstractList:                                                    *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
      modCount

    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      addAll
      clear
      equals
      get
      hashCode
      indexOf
      iterator
      lastIndexOf
      listIterator
      remove
      removeRange
      set
      subList
    *                                                                   *
    *********************************************************************/
   void abstractlist() {
   /* TO BE DETERMINED
      protected  int modCount // The number of times this list has been structurally modified.

      void add(int index, Object element) // Inserts the specified element at the specified position in this list (optional operation).
      boolean add(Object o) // Appends the specified element to the end of this List (optional operation).
      boolean addAll(int index, Collection c) // Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
      void clear() // Removes all of the elements from this collection (optional operation).
      boolean equals(Object o) // Compares the specified object with this list for equality.
      abstract  Object get(int index) // Returns the element at the specified position in this list.
      int hashCode() // Returns the hash code value for this list.
      int indexOf(Object o) // Returns the index in this list of the first occurence of the specified element, or -1 if the list does not contain this element.
      Iterator iterator() // Returns an iterator over the elements in this list in proper sequence.
      int lastIndexOf(Object o) // Returns the index in this list of the last occurence of the specified element, or -1 if the list does not contain this element.
      ListIterator listIterator() // Returns an iterator of the elements in this list (in proper sequence).
      ListIterator listIterator(int index) // Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in the list.
      Object remove(int index) // Removes the element at the specified position in this list (optional operation).
      protected  void removeRange(int fromIndex, int toIndex) // Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
      Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element (optional operation).
      List subList(int fromIndex, int toIndex) // Returns a view of the portion of this list between fromIndex, inclusive, and toIndex, exclusive.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #AbstractMap:                                                     *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      clear
      containsKey
      containsValue
      entrySet
      equals
      get
      hashCode
      isEmpty
      keySet
      put
      putAll
      remove
      size
      toString
      values
    *                                                                   *
    *********************************************************************/
   void abstractmap() {
   /* TO BE DETERMINED
      void clear() // Removes all mappings from this map (optional operation).
      boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
      boolean containsValue(Object value) // Returns true if this map maps one or more keys to this value.
      abstract  Set entrySet() // Returns a set view of the mappings contained in this map.
      boolean equals(Object o) // Compares the specified object with this map for equality.
      Object get(Object key) // Returns the value to which this map maps the specified key.
      int hashCode() // Returns the hash code value for this map.
      boolean isEmpty() // Returns true if this map contains no key-value mappings.
      Set keySet() // Returns a Set view of the keys contained in this map.
      Object put(Object key, Object value) // Associates the specified value with the specified key in this map (optional operation).
      void putAll(Map t) // Copies all of the mappings from the specified map to this map (optional operation).
      Object remove(Object key) // Removes the mapping for this key from this map if present (optional operation).
      int size() // Returns the number of key-value mappings in this map.
      String toString() // Returns a string representation of this map.
      Collection values() // Returns a collection view of the values contained in this map.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #AbstractSequentialList:                                          *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      addAll
      get
      iterator
      listIterator
      remove
      set
    *                                                                   *
    *********************************************************************/
   void abstractsequentiallist() {
   /* TO BE DETERMINED
      void add(int index, Object element) // Inserts the specified element at the specified position in this list.
      boolean addAll(int index, Collection c) // Inserts all of the elements in in the specified collection into this list at the specified position.
      Object get(int index) // Returns the element at the specified position in this list.
      Iterator iterator() // Returns an iterator over the elements in this list (in proper sequence). This implementation merely returns a list iterator over the list.
      abstract  ListIterator listIterator(int index) // Returns a list iterator over the elements in this list (in proper sequence).
      Object remove(int index) // Removes the element at the specified position in this list.
      Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #AbstractSet:                                                     *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      equals
      hashCode
    *                                                                   *
    *********************************************************************/
   void abstractset() {
   /* TO BE DETERMINED
      boolean equals(Object o) // Compares the specified object with this set for equality.
      int hashCode() // Returns the hash code value for this set.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #ArrayList:                                                       *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      addAll
      clear
      clone
      contains
      ensureCapacity
      get
      indexOf
      isEmpty
      lastIndexOf
      remove
      removeRange
      set
      size
      toArray
      trimToSize
    *                                                                   *
    *********************************************************************/
   void arraylist() {
   /* TO BE DETERMINED
      void add(int index, Object element) // Inserts the specified element at the specified position in this list.
      boolean add(Object o) // Appends the specified element to the end of this list.
      boolean addAll(Collection c) // Appends all of the elements in the specified Collection to the end of this list, in the order that they are returned by the specified Collection's Iterator.
      boolean addAll(int index, Collection c) // Inserts all of the elements in the specified Collection into this list, starting at the specified position.
      void clear() // Removes all of the elements from this list.
      Object clone() // Returns a shallow copy of this ArrayList instance.
      boolean contains(Object elem) // Returns true if this list contains the specified element.
      void ensureCapacity(int minCapacity) // Increases the capacity of this ArrayList instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
      Object get(int index) // Returns the element at the specified position in this list.
      int indexOf(Object elem) // Searches for the first occurence of the given argument, testing for equality using the equals method.
      boolean isEmpty() // Tests if this list has no elements.
      int lastIndexOf(Object elem) // Returns the index of the last occurrence of the specified object in this list.
      Object remove(int index) // Removes the element at the specified position in this list.
      protected  void removeRange(int fromIndex, int toIndex) // Removes from this List all of the elements whose index is between fromIndex, inclusive and toIndex, exclusive.
      Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element.
      int size() // Returns the number of elements in this list.
      Object[] toArray() // Returns an array containing all of the elements in this list in the correct order.
      Object[] toArray(Object[] a) // Returns an array containing all of the elements in this list in the correct order.
      void trimToSize() // Trims the capacity of this ArrayList instance to be the list's current size.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #Arrays:                                                          *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      asList
      binarySearch
      equals
      fill
      sort
    *                                                                   *
    *********************************************************************/
   void arrays() {
   /* TO BE DETERMINED
      static List asList(Object[] a) // Returns a fixed-size list backed by the specified array.
      static int binarySearch(byte[] a, byte key) // Searches the specified array of bytes for the specified value using the binary search algorithm.
      static int binarySearch(char[] a, char key) // Searches the specified array of chars for the specified value using the binary search algorithm.
      static int binarySearch(double[] a, double key) // Searches the specified array of doubles for the specified value using the binary search algorithm.
      static int binarySearch(float[] a, float key) // Searches the specified array of floats for the specified value using the binary search algorithm.
      static int binarySearch(int[] a, int key) // Searches the specified array of ints for the specified value using the binary search algorithm.
      static int binarySearch(long[] a, long key) // Searches the specified array of longs for the specified value using the binary search algorithm.
      static int binarySearch(Object[] a, Object key) // Searches the specified array for the specified object using the binary search algorithm.
      static int binarySearch(Object[] a, Object key, Comparator c) // Searches the specified array for the specified object using the binary search algorithm.
      static int binarySearch(short[] a, short key) // Searches the specified array of shorts for the specified value using the binary search algorithm.
      static boolean equals(boolean[] a, boolean[] a2) // Returns true if the two specified arrays of equals are equal to one another.
      static boolean equals(byte[] a, byte[] a2) // Returns true if the two specified arrays of bytes are equal to one another.
      static boolean equals(char[] a, char[] a2) // Returns true if the two specified arrays of chars are equal to one another.
      static boolean equals(double[] a, double[] a2) // Returns true if the two specified arrays of doubles are equal to one another.
      static boolean equals(float[] a, float[] a2) // Returns true if the two specified arrays of floats are equal to one another.
      static boolean equals(int[] a, int[] a2) // Returns true if the two specified arrays of ints are equal to one another.
      static boolean equals(long[] a, long[] a2) // Returns true if the two specified arrays of longs are equal to one another.
      static boolean equals(Object[] a, Object[] a2) // Returns true if the two specified arrays of Objects are equal to one another.
      static boolean equals(short[] a, short[] a2) // Returns true if the two specified arrays of shorts are equal to one another.
      static void fill(boolean[] a, boolean val) // Assigns the specified boolean value to each element of the specified array of booleans.
      static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) // Assigns the specified boolean value to each element of the specified range of the specified array of booleans.
      static void fill(byte[] a, byte val) // Assigns the specified byte value to each element of the specified array of bytes.
      static void fill(byte[] a, int fromIndex, int toIndex, byte val) // Assigns the specified byte value to each element of the specified range of the specified array of bytes.
      static void fill(char[] a, char val) // Assigns the specified char value to each element of the specified array of chars.
      static void fill(char[] a, int fromIndex, int toIndex, char val) // Assigns the specified char value to each element of the specified range of the specified array of chars.
      static void fill(double[] a, double val) // Assigns the specified double value to each element of the specified array of doubles.
      static void fill(double[] a, int fromIndex, int toIndex, double val) // Assigns the specified double value to each element of the specified range of the specified array of doubles.
      static void fill(float[] a, float val) // Assigns the specified float value to each element of the specified array of floats.
      static void fill(float[] a, int fromIndex, int toIndex, float val) // Assigns the specified float value to each element of the specified range of the specified array of floats.
      static void fill(int[] a, int val) // Assigns the specified int value to each element of the specified array of ints.
      static void fill(int[] a, int fromIndex, int toIndex, int val) // Assigns the specified int value to each element of the specified range of the specified array of ints.
      static void fill(long[] a, int fromIndex, int toIndex, long val) // Assigns the specified long value to each element of the specified range of the specified array of longs.
      static void fill(long[] a, long val) // Assigns the specified long value to each element of the specified array of longs.
      static void fill(Object[] a, int fromIndex, int toIndex, Object val) // Assigns the specified Object reference to each element of the specified range of the specified array of Objects.
      static void fill(Object[] a, Object val) // Assigns the specified Object reference to each element of the specified array of Objects.
      static void fill(short[] a, int fromIndex, int toIndex, short val) // Assigns the specified short value to each element of the specified range of the specified array of shorts.
      static void fill(short[] a, short val) // Assigns the specified short value to each element of the specified array of shorts.
      static void sort(byte[] a) // Sorts the specified array of bytes into ascending numerical order.
      static void sort(byte[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of bytes into ascending numerical order.
      static void sort(char[] a) // Sorts the specified array of chars into ascending numerical order.
      static void sort(char[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of chars into ascending numerical order.
      static void sort(double[] a) // Sorts the specified array of doubles into ascending numerical order.
      static void sort(double[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of doubles into ascending numerical order.
      static void sort(float[] a) // Sorts the specified array of floats into ascending numerical order.
      static void sort(float[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of floats into ascending numerical order.
      static void sort(int[] a) // Sorts the specified array of ints into ascending numerical order.
      static void sort(int[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of ints into ascending numerical order.
      static void sort(long[] a) // Sorts the specified array of longs into ascending numerical order.
      static void sort(long[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of longs into ascending numerical order.
      static void sort(Object[] a) // Sorts the specified array of objects into ascending order, according to the natural ordering of its elements.
      static void sort(Object[] a, Comparator c) // Sorts the specified array of objects according to the order induced by the specified comparator.
      static void sort(Object[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of objects into ascending order, according to the natural ordering of its elements.
      static void sort(Object[] a, int fromIndex, int toIndex, Comparator c) // Sorts the specified range of the specified array of objects according to the order induced by the specified comparator.
      static void sort(short[] a) // Sorts the specified array of shorts into ascending numerical order.
      static void sort(short[] a, int fromIndex, int toIndex) // Sorts the specified range of the specified array of shorts into ascending numerical order.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #Collections:                                                     *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
      EMPTY_LIST
      EMPTY_SET

    *    Methods:                                                       *
    *       x                    y                    y                 *
      binarySearch
      copy
      enumeration
      fill
      max
      min
      nCopies
      reverse
      reverseOrder
      shuffle
      singleton
      sort
      synchronizedCollection
      synchronizedList
      synchronizedMap
      synchronizedSet
      synchronizedSortedMap
      synchronizedSortedSet
      unmodifiableCollection
      unmodifiableList
      unmodifiableMap
      unmodifiableSet
      unmodifiableSortedMap
      unmodifiableSortedSet
    *                                                                   *
    *********************************************************************/
   void collections() {
   /* TO BE DETERMINED
      static List EMPTY_LIST // The empty list (immutable).
      static Set EMPTY_SET // The empty set (immutable).

      static int binarySearch(List list, Object key) // Searches the specified list for the specified object using the binary search algorithm.
      static int binarySearch(List list, Object key, Comparator c) // Searches the specified list for the specified object using the binary search algorithm.
      static void copy(List dest, List src) // Copies all of the elements from one list into another.
      static Enumeration enumeration(Collection c) // Returns an enumeration over the specified collection.
      static void fill(List list, Object o) // Replaces all of the elements of the specified list with the specified element.
      static Object max(Collection coll) // Returns the maximum element of the given collection, according to the natural ordering of its elements.
      static Object max(Collection coll, Comparator comp) // Returns the maximum element of the given collection, according to the order induced by the specified comparator.
      static Object min(Collection coll) // Returns the minimum element of the given collection, according to the natural ordering of its elements.
      static Object min(Collection coll, Comparator comp) // Returns the minimum element of the given collection, according to the order induced by the specified comparator.
      static List nCopies(int n, Object o) // Returns an immutable list consisting of n copies of the specified object.
      static void reverse(List l) // Reverses the order of the elements in the specified list. This method runs in linear time.
      static Comparator reverseOrder() // Returns a comparator that imposes the reverse of the natural ordering on a collection of objects that implement the Comparable interface.
      static void shuffle(List list) // Randomly permutes the specified list using a default source of randomness.
      static void shuffle(List list, Random rnd) // Randomly permute the specified list using the specified source of randomness.
      static Set singleton(Object o) // Returns an immutable set containing only the specified object.
      static void sort(List list) // Sorts the specified list into ascending order, according to the natural ordering of its elements.
      static void sort(List list, Comparator c) // Sorts the specified list according to the order induced by the specified comparator.
      static Collection synchronizedCollection(Collection c) // Returns a synchronized (thread-safe) collection backed by the specified collection.
      static List synchronizedList(List list) // Returns a synchronized (thread-safe) list backed by the specified list.
      static Map synchronizedMap(Map m) // Returns a synchronized (thread-safe) map backed by the specified map.
      static Set synchronizedSet(Set s) // Returns a synchronized (thread-safe) set backed by the specified set.
      static SortedMap synchronizedSortedMap(SortedMap m) // Returns a synchronized (thread-safe) sorted map backed by the specified sorted map.
      static SortedSet synchronizedSortedSet(SortedSet s) // Returns a synchronized (thread-safe) sorted set backed by the specified sorted set.
      static Collection unmodifiableCollection(Collection c) // Returns an unmodifiable view of the specified collection.
      static List unmodifiableList(List list) // Returns an unmodifiable view of the specified list.
      static Map unmodifiableMap(Map m) // Returns an unmodifiable view of the specified map.
      static Set unmodifiableSet(Set s) // Returns an unmodifiable view of the specified set.
      static SortedMap unmodifiableSortedMap(SortedMap m) // Returns an unmodifiable view of the specified sorted map.
      static SortedSet unmodifiableSortedSet(SortedSet s) // Returns an unmodifiable view of the specified sorted set.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #HashMap:                                                         *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      clear
      clone
      containsKey
      containsValue
      entrySet
      get
      isEmpty
      keySet
      put
      putAll
      remove
      size
      values
    *                                                                   *
    *********************************************************************/
   void hashmap() {
   /* TO BE DETERMINED
      void clear() // Removes all mappings from this map.
      Object clone() // Returns a shallow copy of this HashMap instance: the keys and values themselves are not cloned.
      boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
      boolean containsValue(Object value) // Returns true if this map maps one or more keys to the specified value.
      Set entrySet() // Returns a collection view of the mappings contained in this map.
      Object get(Object key) // Returns the value to which this map maps the specified key.
      boolean isEmpty() // Returns true if this map contains no key-value mappings.
      Set keySet() // Returns a set view of the keys contained in this map.
      Object put(Object key, Object value) // Associates the specified value with the specified key in this map.
      void putAll(Map t) // Copies all of the mappings from the specified map to this one.
      Object remove(Object key) // Removes the mapping for this key from this map if present.
      int size() // Returns the number of key-value mappings in this map.
      Collection values() // Returns a collection view of the values contained in this map.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #HashSet:                                                         *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      clear
      clone
      contains
      isEmpty
      iterator
      remove
      size
    *                                                                   *
    *********************************************************************/
   void hashset() {
   /* TO BE DETERMINED
      boolean add(Object o) // Adds the specified element to this set if it is not already present.
      void clear() // Removes all of the elements from this set.
      Object clone() // Returns a shallow copy of this HashSet instance: the elements themselves are not cloned.
      boolean contains(Object o) // Returns true if this set contains the specified element.
      boolean isEmpty() // Returns true if this set contains no elements.
      Iterator iterator() // Returns an iterator over the elements in this set.
      boolean remove(Object o) // Removes the given element from this set if it is present.
      int size() // Returns the number of elements in this set (its cardinality).
   */
   }

   /*********************************************************************
    *                                                                   *
    * #LinkedList:                                                      *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      addAll
      addFirst
      addLast
      clear
      clone
      contains
      get
      getFirst
      getLast
      indexOf
      lastIndexOf
      listIterator
      remove
      removeFirst
      removeLast
      set
      size
      toArray
    *                                                                   *
    *********************************************************************/
   void linkedlist() {
   /* TO BE DETERMINED
      void add(int index, Object element) // Inserts the specified element at the specified position in this list.
      boolean add(Object o) // Appends the specified element to the end of this list.
      boolean addAll(Collection c) // Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator.
      boolean addAll(int index, Collection c) // Inserts all of the elements in the specified collection into this list, starting at the specified position.
      void addFirst(Object o) // Inserts the given element at the beginning of this list.
      void addLast(Object o) // Appends the given element to the end of this list.
      void clear() // Removes all of the elements from this list.
      Object clone() // Returns a shallow copy of this LinkedList.
      boolean contains(Object o) // Returns true if this list contains the specified element.
      Object get(int index) // Returns the element at the specified position in this list.
      Object getFirst() // Returns the first element in this list.
      Object getLast() // Returns the last element in this list.
      int indexOf(Object o) // Returns the index in this list of the first occurrence of the specified element, or -1 if the List does not contain this element.
      int lastIndexOf(Object o) // Returns the index in this list of the last occurrence of the specified element, or -1 if the list does not contain this element.
      ListIterator listIterator(int index) // Returns a list-iterator of the elements in this list (in proper sequence), starting at the specified position in the list.
      Object remove(int index) // Removes the element at the specified position in this list.
      boolean remove(Object o) // Removes the first occurrence of the specified element in this list.
      Object removeFirst() // Removes and returns the first element from this list.
      Object removeLast() // Removes and returns the last element from this list.
      Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element.
      int size() // Returns the number of elements in this list.
      Object[] toArray() // Returns an array containing all of the elements in this list in the correct order.
      Object[] toArray(Object[] a) // Returns an array containing all of the elements in this list in the correct order.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #PropertyPermission:                                              *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      equals
      getActions
      hashCode
      implies
      newPermissionCollection
    *                                                                   *
    *********************************************************************/
   void propertypermission() {
   /* TO BE DETERMINED
      boolean equals(Object obj) // Checks two PropertyPermission objects for equality.
      String getActions() // Returns the "canonical string representation" of the actions.
      int hashCode() // Returns the hash code value for this object.
      boolean implies(Permission p) // Checks if this PropertyPermission object "implies" the specified permission.
      PermissionCollection newPermissionCollection() // Returns a new PermissionCollection object for storing PropertyPermission objects.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #TreeMap:                                                         *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      clear
      clone
      comparator
      containsKey
      containsValue
      entrySet
      firstKey
      get
      headMap
      keySet
      lastKey
      put
      putAll
      remove
      size
      subMap
      tailMap
      values
    *                                                                   *
    *********************************************************************/
   void treemap() {
   /* TO BE DETERMINED
      void clear() // Removes all mappings from this TreeMap.
      Object clone() // Returns a shallow copy of this TreeMap instance.
      Comparator comparator() // Returns the comparator used to order this map, or null if this map uses its keys' natural order.
      boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
      boolean containsValue(Object value) // Returns true if this map maps one or more keys to the specified value.
      Set entrySet() // Returns a set view of the mappings contained in this map.
      Object firstKey() // Returns the first (lowest) key currently in this sorted map.
      Object get(Object key) // Returns the value to which this map maps the specified key.
      SortedMap headMap(Object toKey) // Returns a view of the portion of this map whose keys are strictly less than toKey.
      Set keySet() // Returns a Set view of the keys contained in this map.
      Object lastKey() // Returns the last (highest) key currently in this sorted map.
      Object put(Object key, Object value) // Associates the specified value with the specified key in this map.
      void putAll(Map map) // Copies all of the mappings from the specified map to this map.
      Object remove(Object key) // Removes the mapping for this key from this TreeMap if present.
      int size() // Returns the number of key-value mappings in this map.
      SortedMap subMap(Object fromKey, Object toKey) // Returns a view of the portion of this map whose keys range from fromKey, inclusive, to toKey, exclusive.
      SortedMap tailMap(Object fromKey) // Returns a view of the portion of this map whose keys are greater than or equal to fromKey.
      Collection values() // Returns a collection view of the values contained in this map.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #TreeSet:                                                         *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      addAll
      clear
      clone
      comparator
      contains
      first
      headSet
      isEmpty
      iterator
      last
      remove
      size
      subSet
      tailSet
    *                                                                   *
    *********************************************************************/
   void treeset() {
   /* TO BE DETERMINED
      boolean add(Object o) // Adds the specified element to this set if it is not already present.
      boolean addAll(Collection c) // Adds all of the elements in the specified collection to this set.
      void clear() // Removes all of the elements from this set.
      Object clone() // Returns a shallow copy of this TreeSet instance.
      Comparator comparator() // Returns the comparator used to order this sorted set, or null if this tree map uses its keys natural ordering.
      boolean contains(Object o) // Returns true if this set contains the specified element.
      Object first() // Returns the first (lowest) element currently in this sorted set.
      SortedSet headSet(Object toElement) // Returns a view of the portion of this set whose elements are strictly less than toElement.
      boolean isEmpty() // Returns true if this set contains no elements.
      Iterator iterator() // Returns an iterator over the elements in this set.
      Object last() // Returns the last (highest) element currently in this sorted set.
      boolean remove(Object o) // Removes the given element from this set if it is present.
      int size() // Returns the number of elements in this set (its cardinality).
      SortedSet subSet(Object fromElement, Object toElement) // Returns a view of the portion of this set whose elements range from fromElement, inclusive, to toElement, exclusive.
      SortedSet tailSet(Object fromElement) // Returns a view of the portion of this set whose elements are greater than or equal to fromElement.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #WeakHashMap:                                                     *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      clear
      containsKey
      entrySet
      get
      isEmpty
      put
      remove
      size
    *                                                                   *
    *********************************************************************/
   void weakhashmap() {
   /* TO BE DETERMINED
      void clear() // Removes all mappings from this map.
      boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
      Set entrySet() // Returns a Set view of the mappings in this map.
      Object get(Object key) // Returns the value to which this map maps the specified key.
      boolean isEmpty() // Returns true if this map contains no key-value mappings.
      Object put(Object key, Object value) // Updates this map so that the given key maps to the given value.
      Object remove(Object key) // Removes the mapping for the given key from this map, if present.
      int size() // Returns the number of key-value mappings in this map.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #Collection:                                                      *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      addAll
      clear
      contains
      containsAll
      equals
      hashCode
      isEmpty
      iterator
      remove
      removeAll
      retainAll
      size
      toArray
    *                                                                   *
    *********************************************************************/
   void collection() {
   /* TO BE DETERMINED
      boolean add(Object o) // Ensures that this collection contains the specified element (optional operation).
      boolean addAll(Collection c) // Adds all of the elements in the specified collection to this collection (optional operation).
      void clear() // Removes all of the elements from this collection (optional operation).
      boolean contains(Object o) // Returns true if this collection contains the specified element.
      boolean containsAll(Collection c) // Returns true if this collection contains all of the elements in the specified collection.
      boolean equals(Object o) // Compares the specified object with this collection for equality.
      int hashCode() // Returns the hash code value for this collection.
      boolean isEmpty() // Returns true if this collection contains no elements.
      Iterator iterator() // Returns an iterator over the elements in this collection.
      boolean remove(Object o) // Removes a single instance of the specified element from this collection, if it is present (optional operation).
      boolean removeAll(Collection c) // Removes all this collection's elements that are also contained in the specified collection (optional operation).
      boolean retainAll(Collection c) // Retains only the elements in this collection that are contained in the specified collection (optional operation).
      int size() // Returns the number of elements in this collection.
      Object[] toArray() // Returns an array containing all of the elements in this collection.
      Object[] toArray(Object[] a) // Returns an array containing all of the elements in this collection whose runtime type is that of the specified array.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #Comparator:                                                      *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      compare
      equals
    *                                                                   *
    *********************************************************************/
   void comparator() {
   /* TO BE DETERMINED
      int compare(Object o1, Object o2) // Compares its two arguments for order.
      boolean equals(Object obj) // Indicates whether some other object is "equal to" this Comparator.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #Iterator:                                                        *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      hasNext
      next
      remove
    *                                                                   *
    *********************************************************************/
   void iterator() {
   /* TO BE DETERMINED
      boolean hasNext() // Returns true if the iteration has more elements.
      Object next() // Returns the next element in the interation.
      void remove() // Removes from the underlying collection the last element returned by the iterator (optional operation).
   */
   }

   /*********************************************************************
    *                                                                   *
    * #List:                                                            *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      addAll
      clear
      contains
      containsAll
      equals
      get
      hashCode
      indexOf
      isEmpty
      iterator
      lastIndexOf
      listIterator
      listIterator
      remove
      remove
      removeAll
      retainAll
      set
      size
      subList
      toArray
    *                                                                   *
    *********************************************************************/
   void list() {
   /* TO BE DETERMINED
      void add(int index, Object element) // Inserts the specified element at the specified position in this list (optional operation).
      boolean add(Object o) // Appends the specified element to the end of this list (optional operation).
      boolean addAll(Collection c) // Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection's iterator (optional operation).
      boolean addAll(int index, Collection c) // Inserts all of the elements in the specified collection into this list at the specified position (optional operation).
      void clear() // Removes all of the elements from this list (optional operation).
      boolean contains(Object o) // Returns true if this list contains the specified element.
      boolean containsAll(Collection c) // Returns true if this list contains all of the elements of the specified collection.
      boolean equals(Object o) // Compares the specified object with this list for equality.
      Object get(int index) // Returns the element at the specified position in this list.
      int hashCode() // Returns the hash code value for this list.
      int indexOf(Object o) // Returns the index in this list of the first occurrence of the specified element, or -1 if this list does not contain this element.
      boolean isEmpty() // Returns true if this list contains no elements.
      Iterator iterator() // Returns an iterator over the elements in this list in proper sequence.
      int lastIndexOf(Object o) // Returns the index in this list of the last occurrence of the specified element, or -1 if this list does not contain this element.
      ListIterator listIterator() // Returns a list iterator of the elements in this list (in proper sequence).
      ListIterator listIterator(int index) // Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in this list.
      Object remove(int index) // Removes the element at the specified position in this list (optional operation).
      boolean remove(Object o) // Removes the first occurrence in this list of the specified element (optional operation).
      boolean removeAll(Collection c) // Removes from this list all the elements that are contained in the specified collection (optional operation).
      boolean retainAll(Collection c) // Retains only the elements in this list that are contained in the specified collection (optional operation).
      Object set(int index, Object element) // Replaces the element at the specified position in this list with the specified element (optional operation).
      int size() // Returns the number of elements in this list.
      List subList(int fromIndex, int toIndex) // Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive.
      Object[] toArray() // Returns an array containing all of the elements in this list in proper sequence.
      Object[] toArray(Object[] a) // Returns an array containing all of the elements in this list in proper sequence; the runtime type of the returned array is that of the specified array.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #ListIterator:                                                    *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      hasNext
      hasPrevious
      next
      nextIndex
      previous
      previousIndex
      remove
      set
    *                                                                   *
    *********************************************************************/
   void listiterator() {
   /* TO BE DETERMINED
      void add(Object o) // Inserts the specified element into the list (optional operation).
      boolean hasNext() // Returns true if this list iterator has more elements when traversing the list in the forward direction.
      boolean hasPrevious() // Returns true if this list iterator has more elements when traversing the list in the reverse direction.
      Object next() // Returns the next element in the list.
      int nextIndex() // Returns the index of the element that would be returned by a subsequent call to next.
      Object previous() // Returns the previous element in the list.
      int previousIndex() // Returns the index of the element that would be returned by a subsequent call to previous.
      void remove() // Removes from the list the last element that was returned by next or previous (optional operation).
      void set(Object o) // Replaces the last element returned by next or previous with the specified element (optional operation).
   */
   }

   /*********************************************************************
    *                                                                   *
    * #Map:                                                             *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      interface Map.Entry // A map entry
      clear
      containsKey
      containsValue
      entrySet
      equals
      get
      hashCode
      isEmpty
      keySet
      put
      putAll
      remove
      size
      values
    *                                                                   *
    *********************************************************************/
   void map() {
   /* TO BE DETERMINED
      static interface Map.Entry // A map entry (key-value pair).
      void clear() // Removes all mappings from this map (optional operation).
      boolean containsKey(Object key) // Returns true if this map contains a mapping for the specified key.
      boolean containsValue(Object value) // Returns true if this map maps one or more keys to the specified value.
      Set entrySet() // Returns a set view of the mappings contained in this map.
      boolean equals(Object o) // Compares the specified object with this map for equality.
      Object get(Object key) // Returns the value to which this map maps the specified key.
      int hashCode() // Returns the hash code value for this map.
      boolean isEmpty() // Returns true if this map contains no key-value mappings.
      Set keySet() // Returns a set view of the keys contained in this map.
      Object put(Object key, Object value) // Associates the specified value with the specified key in this map (optional operation).
      void putAll(Map t) // Copies all of the mappings from the specified map to this map (optional operation).
      Object remove(Object key) // Removes the mapping for this key from this map if present (optional operation).
      int size() // Returns the number of key-value mappings in this map.
      Collection values() // Returns a collection view of the values contained in this map.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #Map.Entry:                                                       *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      equals
      getKey
      getValue
      hashCode
      setValue
    *                                                                   *
    *********************************************************************/
   void map_entry() {
   /* TO BE DETERMINED
      boolean equals(Object o) // Compares the specified object with this entry for equality.
      Object getKey() // Returns the key corresponding to this entry.
      Object getValue() // Returns the value corresponding to this entry.
      int hashCode() // Returns the hash code value for this map entry.
      Object setValue(Object value) // Replaces the value corresponding to this entry with the specified value (optional operation).
   */
   }

   /*********************************************************************
    *                                                                   *
    * #Set:                                                             *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      add
      addAll
      clear
      contains
      containsAll
      equals
      hashCode
      isEmpty
      iterator
      remove
      removeAll
      retainAll
      size
      toArray
    *                                                                   *
    *********************************************************************/
   void set() {
   /* TO BE DETERMINED
      boolean add(Object o) // Adds the specified element to this set if it is not already present (optional operation).
      boolean addAll(Collection c) // Adds all of the elements in the specified collection to this set if they're not already present (optional operation).
      void clear() // Removes all of the elements from this set (optional operation).
      boolean contains(Object o) // Returns true if this set contains the specified element.
      boolean containsAll(Collection c) // Returns true if this set contains all of the elements of the specified collection.
      boolean equals(Object o) // Compares the specified object with this set for equality.
      int hashCode() // Returns the hash code value for this set.
      boolean isEmpty() // Returns true if this set contains no elements.
      Iterator iterator() // Returns an iterator over the elements in this set.
      boolean remove(Object o) // Removes the specified element from this set if it is present (optional operation).
      boolean removeAll(Collection c) // Removes from this set all of its elements that are contained in the specified collection (optional operation).
      boolean retainAll(Collection c) // Retains only the elements in this set that are contained in the specified collection (optional operation).
      int size() // Returns the number of elements in this set (its cardinality).
      Object[] toArray() // Returns an array containing all of the elements in this set.
      Object[] toArray(Object[] a) // Returns an array containing all of the elements in this set whose runtime type is that of the specified array.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #SortedMap:                                                       *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      interface Map.Entry // A map entry
      clear
      containsKey
      containsValue
      entrySet
      equals
      get
      hashCode
      isEmpty
      keySet
      put
      putAll
      remove
      size
      values
    *                                                                   *
    *********************************************************************/
   void sortedmap() {
   /* TO BE DETERMINED
      Comparator comparator() // Returns the comparator associated with this sorted map, or null if it uses its keys' natural ordering.
      Object firstKey() // Returns the first (lowest) key currently in this sorted map.
      SortedMap headMap(Object toKey) // Returns a view of the portion of this sorted map whose keys are strictly less than toKey.
      Object lastKey() // Returns the last (highest) key currently in this sorted map.
      SortedMap subMap(Object fromKey, Object toKey) // Returns a view of the portion of this sorted map whose keys range from fromKey, inclusive, to toKey, exclusive.
      SortedMap tailMap(Object fromKey) // Returns a view of the portion of this sorted map whose keys are greater than or equal to fromKey.
   */
   }

   /*********************************************************************
    *                                                                   *
    * #SortedSet:                                                       *
    *                                                                   *
    *    Desc:                                                          *
    *                                                                   *
    *    Methods:                                                       *
    *       x                    y                    y                 *
      comparator
      first
      headSet
      last
      subSet
      tailSet
    *                                                                   *
    *********************************************************************/
   void sortedset() {
   /* TO BE DETERMINED
      Comparator comparator() // Returns the comparator associated with this sorted set, or null if it uses its elements' natural ordering.
      Object first() // Returns the first (lowest) element currently in this sorted set.
      SortedSet headSet(Object toElement) // Returns a view of the portion of this sorted set whose elements are strictly less than toElement.
      Object last() // Returns the last (highest) element currently in this sorted set.
      SortedSet subSet(Object fromElement, Object toElement) // Returns a view of the portion of this sorted set whose elements range from fromElement, inclusive, to toElement, exclusive.
      SortedSet tailSet(Object fromElement) // Returns a view of the portion of this sorted set whose elements are greater than or equal to fromElement.
   */
   }
}

Chris Rathman / ChrisRath@aol.com