• An Array:
  • A fixed-size "group" of homogeneous objects each of which is identified by an integer index
• 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" collection with an integer index
• Important Methods:
  • void add(int index, E element)
  • E get(int index)
  • E set(int index, E element)
  • int size()

• Purpose:
  • A "growable" collection that can use any Object as an index/key
• Important Methods:
  • V get(K key)
  • V put(K key, V value)
  • int size()

• An Observation:
  • It must be possible to uniquely identify an Object (since it can be used as the key in a Map)
• Some Internals:
  • Each Object has a hashCode() method that can be used for this purpose (which can be based on the object's address, but needn't be)

• List:
  • ArrayList
  • LinkedList
• Map:
  • HashMap
  • TreeMap

• What Are the Differences?
  • The data structures used (i.e., the way memory is organized)
  • The algorithms used
• Can You Be More Specific?
  • If you want to know more, take CS240 (Data Structures and Algorithms)

• Elements in a Collection:
  • In Java, one can put Object objects in a collection
  • Effectively, this means that you can put any reference type in a collection
• A Shortcoming of this Approach:
  • You are forced to cast the Object to the appropriate type when you retrieve it
  • You may cast it incorrectly and this mistake will only be caught at run-time
• Overcoming this Shortcoming:
  • Use parameterized classes/interfaces

• The Raw ArrayList Class:
  • Contains Object objects
  • An Example:
    List a; a = new ArrayList();
• Parameterizing an ArrayList :
  • Contains objects of a specified type
  • An Example:
    List<String> a; a = new ArrayList<String>();

• The Raw HashMap Class:
  • Uses Object objects as both the key and the value
  • An Example:
    Map h; h = new HashMap();
• Parameterizing a HashMap :
  • Uses keys and values with specified types
  • An Example:
    Map<String, Robot> h; h = new HashMap<String, Robot>();

• The Issue:
  • Sometimes the key and the value are the same
• Examples:
  • A "paint" application in which you add a bunch of different shapes to the canvas
  • A course-requirements application that needs to keep track of the courses you've taken
• What To Do?
  • You could use a Map but it is better (i.e., clearer) to use a Set (like the HashSet )

The parameters for the class are listed (in order) in the dotted rectangle and are used as types elsewhere.

Note that parameters are not explicitly included in constructors. Note also that bound parameters are included in arguments or return types (e.g., the keySet() method returns a Set of K so it is written as Set<K>). Note finally that Map is not "officially" a Collection (for reasons we will discuss later).

• Parameters of add() (in List) and put() (in Map):
  • Must be an (extension of) Object
• Implication:
  • A List and a Map can only contain class types
  • They can't contain an int, double, etc...

• Integer:
  • Deprecated Constructor: Integer(int value)
  • Factory: Integer.valueOf(int value)
  • Accessor: int intValue()
• Double:
  • Deprecated Constructor: Double(double value)
  • Factory: Double.valueOf(double value)
  • Accessor: double doubleValue()

• Some Observations:
  • Wrapper classes are inconvenient
  • It seems like the process could be handled by the compiler
• The Solution:
  • The compiler will automatically box (i.e., wrap) and unbox (unwrap) values when you use parameterized collections

• OptionalInt and OptionalDouble:
  • May or may not contain a value
• Methods:
  • boolean isPresent()
  • int orElse(int default) and double orElse(double default) return the value if present and the default otherwise

• An Example:
  • Map offerings; List cs139, cs159; offerings = new HashMap(); cs139 = new ArrayList(); cs139.add("Harris, J.A."); cs139.add("Harris, N.L."); offerings.put("CS139", cs139); cs159 = new ArrayList(); cs159.add("Bernstein"); cs159.add("Harris, N.L."); offerings.put("CS159", cs159);
• An Observation:
  • This is not type safe

• Recall:
  • When we discussed specialization we considered an example in which there was an (abstract) SecurityQuotation class and two subclasses, StockQuotation and FutureQuotation
• Two Questions:
  • Should we be able to create a type-safe collection (e.g., an ArrayList) that contains children of both types?
  • Can we (in Java)?

• Recall:
  • We can assign a StockQuotation object to a variable that is declared to be a SecurityQuotation (because a StockQuotation "is a" SecurityQuotation)
• A Question:
  • Can we assign an ArrayList<StockQuotation> to a variable of type ArrayList<SecurityQuotation>?

• Another Part of the Java Lexicon:
  • The ? is called the wildcard character
• Java Syntax for Unbounded Wildcards:
  • Collection<?> variable
• Java Syntax for Bounded Wildcards:
  • Collection<? extends Parent> variable