Java Collections

Front 1

What are the 3 key players in the Java Collection Frameworks?

Back 1

Interfaces - abstract notion of a collection type

Implementation - Specific concrete implementations of a collection

Algorithms - searching and sorting

Front 2

What are the two super interfaces in the Collections Framework?

Back 2

Collections and Map

Front 3

What are the 4 main sub-interfaces to Collection ?

Back 3

Collection -> Set, List, Queue, Deque

Front 4

What is Java's strategy for keeping the number of core collection interfaces manageable?

Back 4

Rather than having the interfaces define the exact supported methods, exceptions that are not supported by the specific implementation will throw UnsupportedOperationException

Front 5

What is an example of when UnsupportedOperationException being thrown?

Back 5

The specific implementation of a list might not allow elements to be added once created (Collections.unmodifiableList(existingCollection). In this instance an operation that attempts to add would throw this exception

Front 6

How would you know which operations were supported for a given implementation?

Back 6

Up to the API docs to show this in their JavaDoc

Front 7

What 7 types of operation are available as a bare minumum on a java collection?

Back 7

Adding

Clearing

Checks for element(s) contained within

Checks for empty/size of collection

Associated iterator from the collection

Means to create an array

Remove methods from an array

Front 8

When would you use each type of collection?

Back 8

Set - when I wanted a collection without duplicates

List when I want to order a collection, and control where an element gets inserted

Queue - to hold elements prior to processing

Deque - as per queue

Map - key to values

Front 9

When would I use a sorted set or map

Back 9

When the natural order is important - e.g. a sortedset for a register would be in alphabetical order

A sortedmap would be useful when I was building a book index, or a telephone directory

Front 10

What useful convention do the implementations of the Collections interface have?

Back 10

A constructor argument that takes a collection argument - allowing maximum flexibility in creating new types.

Maps don't have this since they are descended from the collection interface

Front 11

What 3 ways can you traverse a collection? Example of each

Back 11

Aggregate operations - Java 8 - declaratively operate on the collection by calling operations on it

For-each - simple loop over elements in a collection

Iterator - call the iterator on the object to get 'safe' access to modify when you iterate through it.

Front 12

What methods does an Iterator have?

Back 12

hasNext()

next() - the element that

remove() - the only safe way to do so during iteration

Front 13

What are the 5 bulk operations of a collection?

Back 13

clear

containsAll

removeAll

retainAll

addAll

Front 14

Which packages are iterator implementations stored in?

Back 14

Trick question: they are inner classes of the Collections, because they are conceptually coupled to the collection

The iterator interface is a standalone class file though

Front 15

When would using an iterator *still* throw an exception?

Back 15

If the collection that is being returned doesn't support removal then it won't matter if it's been accessed via an iterator. For example, Arrays.asList returns an inner class called Arrays$ArrayList which doesn't support removal, unlike the java.util.ArrayList we're used to.

Front 16

How do the 3 implementations of set differ?

Back 16

Hashset will store elements in a hashtable has better performance, but no guarantees on ordering - a sequential search will not necessarily yield elements in the order they were added, or any natural order.

Treeset is sorted - e.g country list in a drop down, would be retrieved.

LinkedHashset would use a linkedlist as a hastable with a linked list running through it -i.e. elements appear in the

Front 17

How would you provide the union of two collections?

Back 17

Use the addAll method to add only elements that aren't already included in the list

Front 18

How would you provide the intersection of two collections?

Back 18

Use the retainAll method to include only elements present in both sets

Front 19

How could you provide only the unique elements in two collections?

Back 19

Use the removeAll method to remove only elements present in both sets

Front 20

Why does implementing equals but not hashCode violate a set?

Back 20

If the object didn't implement equals then the set would consider all instances unique.

When equals is implemented, the add methods will look up the hash of the object about to be added. If there is an entry for the hashcode and equals is implemented, then the object will replace the existing entry, hence duplicates

Not implementing hashCode means that each object will get its own location in the map.

Front 21

What operations does the List interface provide

Back 21

Positional access - getting/setting and removing at numerical posotions in a list

Search - look for an object rather than a position

Iteration - listIterators provide extended operations

Range View - lists between two points

Front 22

What are the two List implementations offered as standard?

Back 22

ArrayList and LinkedList

Front 23

What are the similarities and differences between add and set and remove?

Back 23

Both take an index as position (overloaded to 0)

Add/Remove will insert/remove from a selected index and return a boolean if the collection was modified

Set and remove will return the old value being overwritten or removed, respectively.

Front 24

What is the difference between Arrays.asList() and new ArrayList?

Back 24

A list constructed from an array will have the a refrnece to the backing array so changes to the collection will reflect to the array, and vice-versa

For this reason, add/remove methods are not supported on ArrayLists created from asList() - since this would affect the backing array too.

Front 25

What extra features does listIterator offer

Back 25

Previous and hasPrevious

previousIndex and nextIndex

Front 26

What useful algorithms does the Collections interface offer for dealing with lists?

Back 26

sort

shuffle

reverse

rotate - move elements by n positions

swap

replaceAll (swap all values for another)

fill (replace global)

binarySearch

indexOfSublist

lastIndexOfSublist

Front 27

Why would I use a queue

Back 27

When I want to hold elements before I process them, typically I would access the first element in the queue rather than by the 'random' access of a list.

Front 28

What methods does a queue have

Back 28

add() - put an element in the queue

remove() take next element from the queue

element() examines the next element according to the queue ordering (non-destructive version of remove)

Front 29

What are the special value counterparts of these operations

Back 29

offer(e) returns false instead of throwing an exception if add fails - it's only intended for use on a bounded queue

poll() will return null if the queue is empty, whereas remove would throw an exception

ditto peek() for element

Front 30

How does a priority queue differ from a standard queue?

Back 30

It uses the natural ordering (or the rules of the comparator passed) to sort, rather than the order inserted

Front 31

What is a deque

Back 31

A collection that implements both queue and stack so LIFO and FIFO

Front 32

What are the three ways of viewing a map as a collection, and how do they differ

Back 32

keySet --> all the keys of a map (set because they are unique by definition

values --> all the values in the map - a collection, since values can be duplicates

entrySet --> a set of each key to value mapping

Front 33

How can you alter a map whilst iterating

Back 33

Use an entry set and the set value method

Front 34

How can I check if two maps have the same keys if not the same values?

Back 34

if (s1.keySet().equals(s2.keySet())

Front 35

How can I check if the same keys *and* values are contained in the same map?

Back 35

if (s1.entrySet().equals(s2.entrySet())

Front 36

How does object sorting in a collection work?

Back 36

The objects in the collection will sort as per the logic in their compareTo implementation of the Comparable interface, known as natural ordering

Front 37

What if an object doesn't implement comparable?

Back 37

You can provide your own Comparator implementation that provides a compare and equals for a given class

Front 38

What if you don't want to use the default compareTo of a class that implements comparable?

Back 38

You can provide your own Comparator implementation that provides a compare and equals for a given class

Front 39

Two reasons that Collections.sort would throw a ClassCast

Back 39

The collection is of a type that doesn't implement comparable

The instances of elements in the collection aren't of a suitable type for the comparator

Front 40

How can you implement a reverse sort with a comparator

Back 40

Flip the parameter compare around i.e. public int compare(Element o1, Element o2) { return o2.compareTo(o1);}

So that the value of the *second* parameter is assessed against the first, resulting in a reverse sort

Front 41

Why is this bad? return e1.number() - e2.number();

Back 41

Because when e2 - e1 produces a low enough number (that wraps around the limits of an int, it will produce a value that is actually positive, and result in the wrong order)

Front 42

What is the definition of an implementation of a collection?

Back 42

The actual data object used to store the collection

Front 43

What is the definition of a 'general-purpose' implementation?

Back 43

The one you'd use under normal circumstances for that kind of collection

Front 44

What are the characteristics of a general purpose implementation?

Back 44

Not thread safe (don't pay for a featrure you might not use) for performance

Fail-fast iterators

Serializable

Implements all the optional operations of the interface

Front 45

How should you use a collection that needs to be thread safe

Back 45

Use the wrappers that exist in the concurrent collection classes

Front 46

What are the advantages of a Hashset

Back 46

Faster, access time is pretty much constant, as you access an object via it's hash

Treeset

Front 47

What is elegant about an EnumSet

Back 47

You can use it to return a restricted range of type-safe values using .of() or range()

Front 48

If I had a range of values that didn't change but I wanted to traverse them quickly, which would be the best implementation and why?

Back 48

CopyOnWriteArraySet uses an array under the covers which is faster, and also immutable.

The downside is adding to it is slower as the underlying array is copied and new elements added to the end.

Front 49

What is the expected hieracy of speed for maps

Back 49

HashMap - general case

LinkedHashset - as long as accessing elements near the top of the list

Treeset - when searching for elements matching the natural order, they might be quicker than a hashset

Front 50

How do the wrapper methods in collections work?

Back 50

Decorator pattern to intercept operations to maintain the contract of the described operation, e.g. Unmodifiable will intercept add and remove methods
Accessed via static factory methods from Collections class

Front 51

What are convenience methods for collections that are useful to know?

Back 51

emptySet

singleton

asList

nCopies