Ch2 - Bag Implementations That Use Arrays Complete Test Bank

Chapter 2 - Bag Implementations that use Arrays

True/False (10)

1. Any methods that a core method might call are part of the core group.
2. You should implement all methods of an ADT implementation before testing to make testing easier.
3. You should never suppress compiler warnings.
4. When defining the bag class, you should implement the isArrayFull and remove operations first.
5. When defining the bag class write methods that have simple implementation first to get them out of the way.
6. A class should not return a reference to an array that is a private data field.
7. A final class is more secure than one that is not final.
8. Write stubs early in the implementation of an ADT so you can begin testing early.
9. When testing a method, you only need to check for arguments that lie within the legal range of their corresponding parameter.
10. When comparing objects in a bag, we assume that the class to which the objects belong defines its own version of equals.

Short Answer (7)

1. It is a good practice to identify a group of core methods to implement and test before continuing with the rest of the class definition. What type of methods should you begin with?
2. Why is it better to implement the add operation in a collection before implementing the remove operation?
3. What is the difference between the numberOfEntries data field in the ArrayBag implementation and the DEFAULT_CAPACITY field?
4. Why is it a safer practice for the toArray method to return a copy of the array instead of a reference to the array?
5. What is fail-safe programming?
6. Why is it a good security practice to declare the ArrayBag to be a final class?
7. Why doesn’t the contains method return the index of a located entry?

Multiple Choice (30) WARNING: CORRECT ANSWERS ARE IN THE SAME POSITION AND TAGGED WITH . YOU SHOULD RANDOMIZE THE LOCATION OF THE CORRECT ANSWERS IN YOUR EXAM.

1. Which of the following methods is a good candidate for a core method:
   1. add()
   2. clear()
   3. contains()
   4. remove()
2. Which of the following methods is a good candidate for a core method:
   1. add()
   2. toArray()
   3. isArrayFull()
   4. all of the above
3. Which one of the following Java statements allocates an array in the bag constructor causing a compiler warning for an unchecked operation? Assume capacity is an integer.
   1. bag = (T[ ]) new Object[capacity];
   2. bag = new T[capacity];
   3. bag = new Object[capacity];
   4. bag = new (T[ ]) Object[capacity];
4. Which instruction suppresses an unchecked-cast warning from the compiler?
   1. @SuppressWarnings(“unchecked”)
   2. @SuppressUnchecked()
   3. @SuppressUncheckedWarnings()
   4. @Warning(“suppress unchecked”)
5. What are the consequences of returning a reference to the bag array in the toArray method?
   1. the return variable is an alias for the private instance array variable
   2. the client will have direct access to the private instance array variable
   3. the client could change the contents of the private instance array variable without using the public access methods
   4. all of the above
6. Which one of the following is considered a safe and secure programming practice?
   1. validating input data and arguments to a method
   2. identifying a group of core methods to implement first
   3. using generic data types
   4. none of the above
7. Which one of the following is considered a safe and secure programming practice?
   1. making no assumptions about the actions of clients and users
   2. using @SupressWarning (“unchecked”)
   3. adding the comments and headers of the public methods to the class by copying them from the interface
   4. all of the above
8. When implementing the bag ADT, which scenario could result in a security problem?
   1. a constructor throws an exception or error before completing its initialization
   2. the programmer validates input data to a method
   3. generics are used to restrict data types of the entries in the collection
   4. a group of core methods is not defined
9. When implementing the bag ADT, which scenario could result in a security problem?
   1. a client attempts to create a bag whose capacity exceeds a given limit
   2. a SecurityException is thrown in the constructor
   3. an IllegalStateException is thrown in the constructor
   4. the delete method is implemented before the add method
10. An incomplete definition of a method is called a _____.
    1. stub
    2. core method
    3. fail-safe method
    4. security problem
11. A stub is created for what purpose?
    1. to avoid syntax errors
    2. to avoid duplicate code
    3. to protect the integrity of the ADT
    4. to practice fail-safe programming
12. A stub should
    1. report that is was invoked by displaying a message
    2. include a return statement that returns a dummy value
    3. be written early for testing programs
    4. all of the above
13. A test driver for the bag add method should check for which one of the following
    1. an over capacity condition
    2. printing elements of the bag
    3. adding elements of the correct type
    4. an empty bag condition
14. The method remove that has no parameter in the bag implementation
    1. removes the last entry in the array
    2. removes the first entry in the array
    3. removes a random entry in the array
    4. none of the above
15. If a bag is empty before the remove method executes, it
    1. returns null
    2. throw an exception
    3. returns an error message
    4. all of the above
16. Decrementing the private class variable numberOfEntries in a bag
    1. causes the last entry to be ignored
    2. causes an IllegalState exception to be thrown
    3. destroys the integrity of the bag container
    4. is a security problem
17. In the remove method, setting the last entry of the array to null
    1. flags the removed object for garbage collection
    2. prevents malicious code from accessing it
    3. is a good security practice
    4. all of the above
18. The remove method replaces the removed entry with null because
    1. the entry could potentially be scheduled for garbage collection
    2. the client expects a null return value
    3. it is a fail-safe programming practice
    4. otherwise it could be considered a duplicate value
19. When calling the remove method with an argument if there are multiple entries
    1. exactly which occurrence removed is unspecified
    2. only one occurrence is removed
    3. the first occurrence is removed
    4. all of the above
20. The most efficient approach to dealing with a gap left in an array after removing an entry from a bag is to
    1. replace the entry being removed with the last entry in the array and replace the last entry with null
    2. replace the entry being removed with the first entry in the array and replace the first entry with null
    3. shift subsequent entries and replace the duplicate reference to the last entry with null
    4. replace the entry being removed with null
21. If an array bag contains the entries “lions”, “elephants”, “otters”, “bears”, “tigers”, “lemurs” and a call to the remove method with the entry “bears” is made, what does the array look like after remove?
    1. ““lions”, “elephants”, “otters”, “lemurs”, “tigers”, null
    2. “lions”, “elephants”, “otters”, null, “tigers”, “lemurs”
    3. “lions”, “elephants”, “otters”, “tigers”, “lemurs”, null
    4. “lions”, “elephants”, “otters”, “tigers”, “lemurs”
22. A return value of -1 from the getIndex method indicates
    1. the entry was not present in the bag
    2. the entry was found at the end of the array
    3. the bag was empty
    4. the bag was full
23. A fixed size array
    1. has a limited capacity
    2. can waste memory
    3. prevents expansion when the bag becomes full
    4. all of the above
24. In order to resize an array to accommodate a larger bag, you must
    1. define an alias that references the original array
    2. create a new array that is larger than the original array and make the alias reference it
    3. copy the contents of the original array reference by the alias to the new array and discard the original array
    4. all of the above
25. When the need to expand the size of a bag occurs, the common practice is to
    1. double the size of the array
    2. increase the size of the array by one to accommodate the new entry
    3. use the Fibonacci sequence to determine the incremental size of the new array
    4. prompt the user for how much larger the bag will need to be
26. The Java Class Library method to resize an array is called
    1. Arrays.copyOf
    2. Arrays.resize
    3. Arrays.copy
    4. Arrays.double
27. When resizing an array to increase the bag size, if the copy exceeds the maximum memory specified for the computer, the checkCapacity method should
    1. throw an IllegalStateException
    2. throw a MaxSizeExceededException
    3. throw a MaxMemoryExceededException
    4. return false
28. In a ResizableArrayBag class, why does the add method always return true?
    1. to conform to the bag interface
    2. because the array will always double in size
    3. returning void is not a fail-safe programming practice
    4. all of the above
29. Which of the following is an advantage of using an array to implement the ADT bag?
    1. adding an entry to a bag is fast
    2. removing a particular entry requires time to locate the entry
    3. increasing the size of the array requires time to copy its entries
    4. the client has control over the size of the bag
30. Which of the following is a disadvantage of using an array to implement the ADT bag?
    1. increasing the size of the array requires time to copy its entries
    2. adding an entry to a bag is fast
    3. removing an unspecified entry from the array is fast
    4. all of the above