Java Collections Framework

Question 1

Java collections framework

Answer 1

A hierarchy of interface types and classes for collecting objects. At the root of this hierarchy is the Collection interface. Because all collections implement this interface, its methods are available for all collection classes. For example, the size method reports the number of elements in any collection.

Question 2

List

Answer 2

A list is a collection that remembers the order of its elements. In Java, the ArrayList class, the Stack class, and the LinkedList class implement the List interface.

Question 3

Set

Answer 3

A set is an unordered collection of unique elements. Because a set does not track the order of its elements, it can arrange them so that the operations of finding, adding, and removing elements is most efficient. In Java, the HashSet and TreeSet classes implement the Set interface.

Question 4

Stack

Answer 4

A stack remembers the order of its elements, but it does not allow you to insert elements in every position. You can only add and remove elements at the top.

Question 5

Queue

Answer 5

In a queue, you add items to one end (the tail) and remove them from the other end (the head).

Question 6

Priority queue

Answer 6

A priority queue is an unordered collection that has an efficient operation for removing the element with the highest priority. In Java, the PriorityQueue class implements the Queue interface.

Question 7

Map

Answer 7

A map manages associations between keys and values. Every key in the map has an associated value. The map stores the key, the values, and the associations between them. In Java, the HashMap and TreeMap classes implement the Map interface.

Question 8

LinkedList

Answer 8

A data structure that is used for collecting a sequence of objects that allows efficient additional and removal of elements in the middle of the sequence. A LinkedList consists of a number of nodes, each of which is an object that stores an element and has a reference to the next node. Therefore, when you insert a new node into a LinkedList, only the neighboring node references need to be updated.

Question 9

What is one advantage of a LinkedList compared to an ArrayList?

Answer 9

Unlike an ArrayList, a LinkedList allows efficient insertion and removal of elements in the middle of the list. (Remember that when an element is added or removed from an an ArrayList, the elements at larger positions must be moved.)

Question 10

What is one drawback of a LinkedList?

Answer 10

Element access can be inefficient because if you want to access the fifth element in a LinkedList, then you must first traverse the first four. Therefore you use a LinkedList when you are concerned about the efficiency of adding or removing elements as opposed to accessing them in a random order.

Question 11

What are the most commonly used methods of the LinkedList class?

Answer 11

There are in built methods for accessing, adding or removing elements at the beginning or end of the LinkedList:

• addLast
• addFirst
• getFirst
• getLast
• removeFirst
• removeLast

* Note, to access other elements you need to use an iterator.

Question 12

What is the syntax for declaring a new HashMap?

Answer 12

HashMap<Integer, String> names = new HashMap<*I**nteger, String>( );

*Where Integer is the data type of key, String is the data type of the value, and names is the reference variable for the HashMap.

** Note that the key HAS TO BE UNIQUE!*

Question 13

Iterator

Answer 13

An iterator encapsulates a position anywhere inside the LinkedList. Initially it points before the first element. However, you can move the iterator position with the next() method:
iterator.next();

* Note that the next() method throws a NoSuchElementException if you are already past the end of the list so you should always call the iterator’s hasNext() method before calling the next() method.

Question 14

What is an essential difference between a collection and a set?

Answer 14

A set does not admit duplicates! If you try to add an element to a set that’s already present, the insertion is ignored. Similarly, attempting to remove an element that isn’t present in the set is ignored. You can use the contains method to test if an element is contained in the set. For example:
if (names.contains(“Juliet”))

Question 15

Common methods for working with sets

Answer 15

• .add()
• .remove()
• .contains()

Question 16

Common methods for working with maps

Answer 16

• .put() - adds keys and values to the map
• .get() - returns the value associated with the key or null if the key is not present
• .remove() - removes the key and value

Question 17

How do you choose the right collection to use?

Answer 17

1. Determine how to access the values. You have a few options:
   
   • If values are accessed by an integer position, use an ArrayList
   • If values are accessed by a key that is not part of the object, use a map
   • If values are accessed only at one of the ends, use a queue for FIFO or a stack for LIFO
   • If you don’t need to access individual values by position, refine you choice in steps 3 and 4
2. Determine the element types or key / value types that you want to store.
3. Determine whether element or key order matters. You have several choices:
   
   • If elements or keys must be sorted, use a TreeSet or TreeMap
   • If elements must be in the same order in which they were inserted, then use an ArrayList or LinkedList
   • If order doesn’t matter and you chose a map in step 1, then proceed to step 5
4. For a collection, determine which operations must be efficient
   
   • If finding elements must be efficient, use a HashSet
   • If it must be efficient to add or remove elements, then use a LinkedIn
   • If you only insert or remove at the end or you’re not concerned about speed, then use an ArrayList
5. For hash sets and maps, decide whether you need to implement the hashCode and equals methods. The classes in the standard Java library will mostly all have these already, but if you’re not using one of these then you’ll need to check to confirm.
6. If you use a tree, decide whether to supply a comparator. Most classes in the standard Java library already implement the Comparable interface and have a compareTo method, but if you’re not using one of these then you’ll need to check to confirm.

Question 18

Hash function / hash code

Answer 18

A function that computes a hash code, a unique integer value, for an object. A good hash function minimizes collisions so no two objects have the same hash code. Becausing hashing is so important, the Object class has a hashCode method:
int hash = x.hashCode();

Question 19

keySet

Answer 19

The collection of unique keys in a HashMap. Java has an inbuilt method for retrieving all keys for a given HashMap, keySet( ), which can then be used to retrieve all corresponding values. For example:
Set keySet = m.keySet( );

for (String key : keySet)

{

Color value = m.get(key);
System.out.println(key + “->” + value);
}

Question 20

How do you iterate through all of the key value pairs in a HashMap?

Answer 20

Use a for loop, or enhanced for loop:

for (String key : movieToActors.keySet( ) )

{
 // your code here
}