• An Array:
  • A fixed-size collection of homogeneous objects that are indexed by an integer
• Limitations of Arrays:
  • Fixed size
  • Must be indexed by an integer

• Fixed Size:
  • When we don't know even the maximum number of elements in the collection beforehand
• Integer Index:
  • When the indices aren't numbers (e.g., names)
  • When the "important" integers are sparse (e.g., phone numbers)

• Collection:
  • An object that "groups" multiple elements into a single unit
• Examples in Java:
  • List
  • Map

• Aggregation:
  • An object of class A "has-an" object of class B if B is a part of A.
• Obvious Applications to Collections:
  • 
• Less Obvious Applications:
  • 

• Purpose:
  • A "growable array" with an integer index
• Important Methods:
  • void add(int index, Object element)
  • Object get(int index)
  • int size()

• Some Convenient Methods:
  • void add(Object element)
  • void clear()
• Some Methods to Avoid For Now:
  • boolean contains(int index, Object element)
  • int indexOf(Object element)

• Purpose:
  • A "growable array" that can use an object as an index/key
• Important Methods:
  • Object get(Object key)
  • Object put(Object key, Object element)
  • int size()
• What Does put() Return:
  • The previous value associated with the key (or null) if there was no such value

• Parameters of add() (in ArrayList) and put() (in HashMap):
  • A Object
• Implication:
  • An ArrayList and a HashMap can only contain objects
  • They can't contain an int, double, etc...

• Integer:
  • Constructor: Integer(int value)
  • Accessor: int intValue()
• Double:
  • Constructor: Double(double value)
  • Accessor: double doubleValue()

• Some Observations:
  • Wrapper classes are inconvenient
  • It seems like the process could be handled by the compiler
• The Solution:
  • Autoboxing - the Java compiler will automatically box and unbox in many situations

• The Motivation:
  • They key is normally an Object that uniquely identifies the value Object
  • Sometimes the value Object does not have an attribute (or attributes) that can be used for this purpose
• Some Observations:
  • The Java interpreter has a way of uniquely identifying each object - its address
  • Each Object also has a Object.hashCode() method that can be used for this purpose (which can be based on the address but needn't be)

• The Result:
  • Sometimes the key and the value are the same
• An Example:
  • A "paint" application in which you add a bunch of different shapes to the canvas
• What To Do?
  • You can use a HashMap, but you can also use a HashSet

• Computers vs. Calculators:
  • Computers can perform the same operation many times
• Programming Languages:
  • Harness this power using loops
• A Problem:
  • Traditional looping requires an understanding of the structure of the collection/aggregate

We don't know all of the keys unless we keep them in another collection

• Applications often "loop" over the same collection/aggregate object in many classes and methods
• Changing from one colelction/aggregate to another is, as a result, very inconvenient
• The Iterator design pattern enables us to access the elements of an aggregate object while hiding its internal structure

• Reset its "pointer" (or cursor) to the first element.
• Determine if there are any more elements in the sequence.
• Move its "pointer" to the next element.
• Retrieve the "current" element.

• The Iterator:
  • Iterator
• Some Aggregates:
  • ArrayList
  • HashSet