ITSW 3173 D287 Java Frameworks

Correct Answer

D. Vector

Explanation

The Vector class in Java is synchronized, meaning that its methods for modifying elements (such as add(), remove(), and set()) are thread-safe. This ensures that only one thread can access and modify the vector at a time, which can be beneficial in multi-threaded environments. However, synchronization can lead to performance overhead compared to non-synchronized collections like ArrayList.

Why other options are wrong

A. ArrayList

This is incorrect because ArrayList is not synchronized. It is not thread-safe by default, so if multiple threads are accessing it concurrently, synchronization must be handled externally.

B. LinkedList

This is incorrect because LinkedList is also not synchronized. Like ArrayList, it is not thread-safe by default, and external synchronization is required if it is accessed by multiple threads.

C. Stack

This is incorrect because although Stack is part of the legacy collection classes, its methods are synchronized. However, Vector is the more commonly referenced synchronized collection in modern use. The distinction in the question specifically points to Vector as the synchronized collection.

Correct Answer

B. List, Map, Set, Queue

Explanation

The Java Collections Framework includes several core interfaces that define various types of collections. These four interfaces—List, Map, Set, and Queue—are part of the framework. A List allows ordered elements with duplicates, a Map stores key-value pairs, a Set ensures no duplicates, and a Queue is used for holding elements before processing.

Why other options are wrong

A. ArrayList, Map, Set, Queue

This is incorrect because ArrayList is a class that implements the List interface, not an interface itself. The correct answer should include the List interface, not ArrayList as a collection class.

C. List, Map, HashSet, PriorityQueue

This is incorrect because HashSet and PriorityQueue are concrete classes, not interfaces. The question specifically asks for interfaces, so the correct answer should only include interfaces, not classes.

D. List, HashMap, HashSet, PriorityQueue

This is incorrect because HashMap, HashSet, and PriorityQueue are all concrete classes, not interfaces. The correct answer must include interfaces only, such as List, Map, Set, and Queue.

Correct Answer

B. To traverse elements in a collection sequentially

Explanation

The primary function of an Iterator in the Java Collections Framework is to traverse through the elements of a collection (like ArrayList, HashSet, etc.) sequentially. This allows you to access each element one by one and manipulate the collection during the iteration. The Iterator provides methods like hasNext() and next() to facilitate this process.

Why other options are wrong

A. To sort elements in a collection

This is incorrect because the Iterator does not perform sorting. Sorting is typically done using other tools like Collections.sort() or a TreeSet, but not by an Iterator.

C. To store elements in key/value pairs

This is wrong because storing key/value pairs is the function of a Map (such as HashMap or TreeMap), not an Iterator. An Iterator does not store data, it merely provides a way to access elements in a collection.

D. To remove duplicates from a collection

This is incorrect. An Iterator does not remove duplicates from a collection. Duplicates are typically removed manually or by using specific collections that do not allow duplicates, such as a Set. An Iterator only provides the ability to traverse and optionally remove elements during iteration.llections class does not return a sorted collection. Instead, it sorts the collection in place. It modifies the collection passed to it, so the method does not return a new collection. This makes it different from other methods that might return a modified copy of the collection.

Correct Answer

A. A Queue follows First In, First Out (FIFO).

Explanation

A Queue operates on a First In, First Out (FIFO) principle, meaning that the first element added is the first one to be removed. This is the defining characteristic of queues and distinguishes them from stacks, which operate on a Last In, First Out (LIFO) basis. Queues are ideal for scheduling and managing tasks in the order they arrive.

Why other options are wrong

B. A Queue allows random access to its elements

This is incorrect because queues do not allow random access. Access is restricted to the front (for removal) and the rear (for insertion). Random access is a characteristic of structures like arrays or lists, not queues.

C. A Stack allows only sequential access from the top

While this statement is true about stacks, it does not address the distinguishing feature of a queue. The question specifically asks about what sets a queue apart, not a stack. Hence, this answer does not directly satisfy the question’s requirement.

D. A Queue follows Last In, First Out (LIFO)

This is incorrect because LIFO is the behavior of a stack, not a queue. A queue’s structure is designed to process elements in the order they arrive, which is FIFO, making this answer fundamentally incorrect.

Correct Answer

A. LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)

Explanation

To create a LinkedHashMap that maintains access order (meaning it reorders entries based on access, not just insertion), you must use the constructor with all three parameters: initial capacity, load factor, and a boolean flag for access order. When accessOrder is set to true, the map maintains access order rather than insertion order.

Why other options are wrong

B. LinkedHashMap(int initialCapacity)

This constructor allows setting only the initial capacity of the map. It does not offer control over access order, so the map will use the default (insertion order), not access order.

C. LinkedHashMap()

This no-argument constructor creates a LinkedHashMap with default capacity and load factor, and it maintains insertion order by default. It does not allow you to specify access order, which is essential for the behavior asked in the question.

D. LinkedHashMap(float loadFactor, boolean accessOrder)

This is incorrect because there is no such constructor in the LinkedHashMap class that takes only a float and a boolean as parameters. To specify access order, you must also provide the initial capacity.

Correct Answer

D. An object that stores a group of other objects, called its elements

Explanation

In Java, a Collection is an object that stores a group of elements, which are typically objects. The Java Collections Framework provides several interfaces (e.g., List, Set, Queue) and classes (e.g., ArrayList, HashSet, LinkedList) that allow us to store and manipulate these collections of objects. Collections do not store primitive types like int or char, but instead store objects.

Why other options are wrong

A. An array that stores a group of user-inputted variables, called its elements

This is incorrect because collections in Java are not arrays. Collections are more flexible and can dynamically resize and manage objects, whereas arrays have a fixed size.

B. An array that stores a group of objects, called its elements

This is incorrect because although arrays can store objects, they are not part of the Collection framework. The Collection framework is designed to provide more powerful and flexible ways to manage groups of objects.

C. An object that stores a group of user-inputted variables, called its elements

This is incorrect because Collection objects store groups of objects (instances of classes), not just any type of user-inputted variables. The elements in a collection are objects, not raw input variables.

E. None of the Above

This is incorrect because the correct description of a Collection is provided in option D.

Correct Answer

C. To associate keys with values

Explanation

The Map interface in Java is designed to store key-value pairs, where each key is associated with exactly one value. It enables efficient retrieval, insertion, and deletion of elements based on the key. This makes Map ideal for scenarios requiring quick access to data using identifiers, like lookup tables.

Why other options are wrong

A. To store elements in a sorted order

This is incorrect because sorting is not the primary function of a Map. While some implementations like TreeMap do store entries in a sorted order based on keys, the core purpose of the Map interface is to associate keys with values, not to maintain order.

B. To maintain a collection of unique elements

This is incorrect because the Set interface is specifically designed for maintaining a collection of unique elements. In a Map, uniqueness is enforced only on keys, not on values. Duplicate values are allowed, so this option does not accurately describe a Map.

D. To allow duplicate entries

This is incorrect because Map does not allow duplicate keys. Although it allows duplicate values, the uniqueness of keys is a fundamental characteristic of Map. This option could be misleading and doesn't describe the primary function of a Map.

Correct Answer

C. Vector is the same as ArrayList, except that it contains synchronized methods for accessing and modifying the vector.

Explanation

The main difference between Vector and ArrayList is that Vector is synchronized, making its methods thread-safe. This synchronization ensures that only one thread can access and modify the vector at any given time, which can be beneficial in multi-threaded environments. On the other hand, ArrayList is not synchronized and is generally preferred in single-threaded scenarios because it has better performance due to the lack of synchronization overhead.

Why other options are wrong

A. Vector is the same as ArrayList, just older.

This is incorrect because the difference between Vector and ArrayList is not just age, but also the fact that Vector is synchronized, while ArrayList is not. This is a significant difference in terms of thread-safety and performance.

B. Vector is the same as ArrayList, except that it contains asynchronous methods for accessing and modifying the vector.

This is incorrect because Vector is synchronized, not asynchronous. Synchronized methods ensure that the operations are thread-safe, not asynchronous.

D. ArrayLists is more widely used in Java legacy code than Vector.

This is incorrect because Vector is part of the legacy collection classes, and it is actually used more widely in older Java code, not ArrayList. ArrayList has largely replaced Vector in modern Java programming.

Correct Answer

A. Sort returns a sorted collection

Explanation

The sort method in the Collections class does not return a sorted collection. Instead, it sorts the collection in place. It modifies the collection passed to it, so the method does not return a new collection. This makes it different from other methods that might return a modified copy of the collection.

Why other options are wrong

B. There are 2 overloaded sort methods. One takes one parameter, the other one two.

This is correct. The sort method has two overloaded versions: one that takes a single List parameter and sorts it in ascending order, and another that accepts a List and a Comparator as parameters, allowing you to define the sorting order (e.g., reverse order).

C. Sort returns nothing but it changes the collection that was passed as an argument

This is accurate. The sort method modifies the collection directly, and it has a void return type, meaning it does not return a sorted collection but instead sorts the original collection in place.

D. The second parameter lets you define how the collection should be sorted - for example in reverse order

This is correct. When using the overloaded sort method with two parameters, the second parameter is a Comparator that lets you specify custom sorting logic, including sorting in reverse order or any other defined order.