Beruflich Dokumente
Kultur Dokumente
Question 1
Which implementation of the List interface produces the slowest access to an element in
the middle of the list by means of an index?
a. Vector
b. ArrayList
c. LinkedList
d. None of the above
ANSWER
ArrayList and Vector both use an array to store the elements of
the list; so access to any element using an index is very fast. A
1 c LinkedList
LinkedList is implemented using a doubly linked list; so access
to an element requires the list to be traversed using the links.
Question 2
import java.util.*;
class GFC100 {
public static void main (String args[]) {
Object a1 = new LinkedList(), b1 = new TreeSet();
Object c1 = new TreeMap();
System.out.print((a1 instanceof Collection)+",");
System.out.print((b1 instanceof Collection)+",");
System.out.print(c1 instanceof Collection);
}}
Question 3
Suppose that an instance of class C has legal implementations of the hashCode and equals
methods. Within any one execution of the Java application, the hash code contract
requires that each invocation of the hashCode method on the same instance of class C
must consistently return the same result as long as the fields used for the equals
comparison remain unchanged.
a. false
b. true
ANSWER
3 b true
Question 4
• Each element must be unique.
• Contains no duplicate elements.
• Elements are not key/value pairs.
Accessing an element can be almost as fast as performing a similar operation on an
•
array.
a. LinkedList
b. TreeMap
c. TreeSet
d. HashMap
e. HashSet
f. LinkedHashMap
g. Hashtable
h. None of the above
ANSWER
The elements of a Map are key/value pairs; so a Map is not a good
choice. A List generally accepts duplicate elements. A Set stores a
collection of unique elements. Any attempt to store a duplicate
element in a Set is rejected. Adding and removing an element in a
TreeSet involves walking the tree to determine the location of the
element. A HashSet stores the elements in a hashtable; so elements in
4 e HashSet a HashSet can be accessed almost as quickly as elements in an array
as long as the hash function disperses the elements properly.
Although the LinkedHashSet is not among the answer options it
could arguably satisfy the requirements. However, the put and
remove methods of the LinkedHashSet are a little slower than the
same methods of the HashSet due to the need to maintain the linked
list through the elements of the LinkedHashSet.
Question 5
import java.util.*;
class GFC101 {
public static void main (String args[]) {
Object a1 = new HashMap(), b1 = new ArrayList();
Object c1 = new HashSet();
System.out.print((a1 instanceof Collection)+",");
System.out.print((b1 instanceof Collection)+",");
System.out.print(c1 instanceof Collection);
}}
ANSWER
5 d Prints: The Map interface does not extend Collection. The reference
false,true,true variable a1 refers to an instance of HashMap; so the relational
expression a1 instanceof Collection returns the value false. The
List and Set interfaces extend the Collection interface; so both
List and Set could be cast to type Collection without generating a
ClassCastException. Therefore, the second and third relational
expressions return true.
Question 6
If two instances of a class type are equal according to the equals method, then the same
integer value must be returned by the hashCode method of the two objects.
a. false
b. true
ANSWER
If two objects are equal according to the equals method, then the hashcodes
produced by the hashCode method must also be equal. If two objects are not
equal according to the equals method, then the hashcodes may or may not
6 b true be equal. It is preferable that unequal objects have different hashcodes, but
that is not always possible. Since the hash code value is a 32 bit primitive
int, it is not possible to produce a unique hash code for each value of a
primitive long.
Question 7
• Entries are organized as key/value pairs.
• Duplicate entries replace old entries.
a. List
b. Map
c. Set
d. None of the above
ANSWER
The List and Set interfaces do not support key/value pairs. A list generally
7 b Map
allows duplicate entries. A Set rejects duplicate entries.
Question 8
import java.util.*;
class GFC102 {
public static void main (String args[]) {
Object a = new HashSet();
System.out.print((a instanceof Set)+",");
System.out.print(a instanceof SortedSet);
}}
ANSWER
Prints: HashSet implements the Set interface, but not the SortedSet
8 c
true,false interface.
Question 9
If two instances of a class type are not equal according to the equals method, then the
same integer value must not be returned by the hashCode method of the two objects.
a. false
b. true
ANSWER
If two objects are equal according to the equals method, then the hashcodes
must also be equal. If two objects are not equal according to the equals
method, then the hashcodes may or may not be equal. It is preferable that
9 a false
unequal objects have different hashcodes, but that is not always possible.
Since the hash code value is a 32 bit primitive int, it is not possible to
produce a unique hash code for each value of a primitive long.
Question 10
Which implementation of the List interface provides for the fastest insertion of a new
element into the middle of the list?
a. Vector
b. ArrayList
c. LinkedList
d. None of the above
ANSWER
ArrayList and Vector both use an array to store the elements of
the list. When an element is inserted into the middle of the list
the elements that follow the insertion point must be shifted to
make room for the new element. The LinkedList is
10 c LinkedList
implemented using a doubly linked list; an insertion requires
only the updating of the links at the point of insertion.
Therefore, the LinkedList allows for fast insertions and
deletions.
Question 11
import java.util.*;
class GFC103 {
public static void main (String args[]) {
Object a1 = new TreeSet();
System.out.print((a1 instanceof Set)+",");
System.out.print(a1 instanceof SortedSet);
}}
ANSWER
Prints: TreeSet implements the Set interface and the SortedSet
11 d
true,true interface.
Question 12
class A {
static void m1 (B a, B b, B c, B d, B e, B f, B g, B h) {
if (a.equals(b)) {System.out.print("A");}
if (!c.equals(d)) {System.out.print("B");}
if (e.hashCode() == f.hashCode()) {System.out.print("C");}
if (g.hashCode() != h.hashCode()) {System.out.print("D");}
}}
Suppose that method m1 is invoked with eight instances of the same class and the output
is ABCD. If the B.equals and B.hashCode methods are implemented according to the
hash code contract, then which of the following statements must always be true?
ANSWER
If two objects are equal according to the equals
method, then the hashcodes must also be equal. If
two objects are not equal according to the equals
(a.hashCode() ==
a method, then the hashcodes may or may not be
12 b.hashCode()) (!
d equal. If two objects have the same hash code, then
g.equals(h))
the objects may or may not be equal. If two objects
have different hashcodes, then the objects must not
be equal.
Question 13
• Stores key/value pairs.
• Duplicate entries replace old entries.
• Entries are sorted using a Comparator or the Comparable interface.
a. LinkedList
b. TreeMap
c. TreeSet
d. HashMap
e. HashSet
f. Hashtable
g. None of the above
ANSWER
13 b TreeMap The requirement to store key/value pairs is directly satisfied by a
concrete implementation of the Map interface. The List and Set
interfaces recognize objects, but do not recognize keys and values.
TreeMap and TreeSet store elements in a sorted order based on the
key, but the TreeSet does not support key/value pairs.
Question 14
import java.util.*;
class GFC104 {
public static void main (String args[]) {
LinkedList a1 = new LinkedList();
ArrayList b1 = new ArrayList();
Vector c1 = new Vector();
System.out.print((a1 instanceof List)+",");
System.out.print((b1 instanceof List)+",");
System.out.print(c1 instanceof List);
}}
ANSWER
Prints: The 1.2 version of Java introduced the updated Vector class
14 h
true,true,true that implements the List interface.
Question 15
class B {
private int i1;
public int hashCode() {return 1;}
}
class C {
private int i1;
public int hashCode() {return -1;}
}
class D {
private int i1;
public int hashCode() {return i1;}
}
Suppose that the equals method of classes B, C and D all make use of the value of the int
variable, i1. Which class has a hashCode method that is not consistent with the hash code
contract?
a. B
b. C
c. D
d. None of the above
ANSWER
Suppose that the hashCode method is invoked on the same object
more than once during the same execution of a Java application. If no
information used in the equals comparison is modified, then each
invocation of the hashCode method must produce the same hash code
None of value. The hashCode methods of classes B and C will always return
15 d the the same value during an execution of the Java application and are
above therefore consistent with the hash code contract. Even so, the
hashCode methods of classes B and C are not efficient, because they
will cause hashtables to place every instance of classes B and C in the
same bucket. The hashCode method of class D is appropriate and will
allow a hash table to operate efficiently.
Question 16
• Entries are not organized as key/value pairs.
• Duplicate entries are rejected.
a. List
b. Map
c. Set
d. None of the above
ANSWER
The Map interface organizes entries as key/value pairs. A list generally
16 c Set
allows duplicate entries. A Set rejects duplicate entries.
Question 17
import java.util.*;
class GFC105 {
public static void main (String args[]) {
Object a = new HashSet(), b = new HashMap();
Object c = new Hashtable();
System.out.print((a instanceof Collection)+",");
System.out.print((b instanceof Collection)+",");
System.out.print(c instanceof Collection);
}}
ANSWER
HashSet is a subclass of AbstractSet and AbstractCollection;
therefore, it implements the Collection interface. HashMap and
Prints: Hashtable do not implement the Collection interface. Instead,
17 e
true,false,false HashMap extends AbstractMap and implements the Map
interface. Hashtable extends Dictionary and implements the
Map interface.
Question 18
Which of the following classes override both the equals and hashCode methods?
a. java.lang.Byte
b. java.lang.Integer
c. java.util.Vector
d. java.lang.String
e. java.lang.StringBuffer
ANSWER
The wrapper classes and the collection
a
classes override the equals and hashCode
b java.lang.Byte java.lang.Integer
18 methods. The String class overrides the
c java.util.Vector java.lang.String
equals and hashCode methods, but
d
StringBuffer does not.