[JAVA][Beginning Java 8 Games Development]

Chapter 10 ■ Directing the Cast of Actors: Creating a Casting Director Engine and Creating the Bagel Actor Class
Finally, the List interface provides three methods that manipulate the entire List using a single method. Since
we are using the List to manage all of the Actor objects currently in the scene, we will primarily be using these methods,
which were mentioned earlier in the ArrayList section of the chapter and include .addAll(), .removeAll(), and .clear().
We will also be using the .add(E element) method to add a single Actor object to our CURRENT_CAST List.
Finally, while it is technically permissible for a List to contain itself as an element, this is not viewed as being
a “good” programming practice, so I do not recommend doing this. You should use extreme caution if you are going to
try doing this, because the equals and hashCode methods will no longer be “well defined” in such a List.
Set and HashSet: Using java.util Unordered Sets
The Set public interface is also a member of the Java Collections Framework. The Java public interface Set
extends the Collections public interface, which extends the Iterable public interface. Thus, the super interface
to sub interface hierarchy for Set is the same as it is for List and looks like the following interface hierarchy:
Interface Iterable
> Interface Collection
> Interface Set
A Set is an unordered Collection and could also be thought of as a random collection of objects in
no particular order. A Set collection may contains no duplicate elements, and will throw an error, called an
“exception,” if a duplicate element is added to the Set or if any “mutable” (elements than can change into
something else) element is changed into an element that duplicates another element already in the Set. This no
duplicates rule also means that at the most, a Set can contain only one single null element. As all of you who are
well versed in mathematics may have surmised already, this Set interface is modeled after the mathematical set
you learned about in school.
The Set interface places additional stipulations beyond those that are “inherited” from the Collection
super interface, on the “contracts” (requirements for all of you non-legal types) for all constructor methods, as well as
on the contracts (requirements) of the .add(), .equals(), and .hashCode() related methods.
The additional stipulations on these constructor methods is, according to rule, that all constructors must create a
Set containing zero duplicate elements.
As mentioned earlier, you must be careful regarding what you are doing if mutable (changeable) objects are used
as elements in a Set collection. The behavior of the Set is not specified if the value of an object is changed in
a manner that affects the .equals() method comparisons while the mutable object is an element in that Set. The
special case of this prohibition is that it is not permissible for a Set to contain itself as an element, as a List can.
The java.util HashSet Class: Using Unordered Sets of Objects
Next, let’s cover the public class HashSet that is a member of the Java Collections Framework as well. This
class that provides a HashSet object container for the Set interface specification is similar to the way that the
ArrayList class creates an ArrayList object container for the List interface. The HashSet class can “implement”
or support the following Java Interfaces: Serializable, Cloneable, Iterable, Collection, and Set. We will be
using the Set, or in our case, Set interface, in our CastingDirector.java class. The Set class hierarchy is
as follows:
java.lang.Object
> java.util.AbstractCollection
> java.util.AbstractSet
> java.util.HashSet
212
www.it-ebooks.info