Collections Framework

Question 1

How can you create an unmodifiable List?

Answer 1

1. List.of(arr)
2. List.copyOf(collection)

Question 2

What are the 2 most modern ways of iterating through a Collection?

Answer 2

1. Stream API
2. obj.forEach(...)

Question 3

What are the 2 different ways of creating an unmodifiable Set?

Answer 3

1. Set.of(arrays)
2. Set.copyOf(collection)

Question 4

What are the 3 rules for implementing Comparable<T>?

Answer 4

int obj.compareTo(T o)

1. If obj < o, return -1
2. If obj == o, return 0
3. If obj > o return 1

Question 5

What are the differences between Comparable<T> and Comparator<T>?

Answer 5

Comparable<T> is implemented as a class. Comparator<T> is implemented as a lambda

Question 6

If both Comparable<T> and Comparator<T> are used, which one will have precedence?

Answer 6

Comparator<T>

Question 7

True or False

Comparable<T> or Comparator<T> should be consistent with an object’s equals() method

Answer 7

True

Question 8

What is the difference between map.put(...) and map.putIfAbsent(...)?

Answer 8

map.put() will override values if key already exists. map.putIfAbsent() will not override values if key already exists

Question 9

What are the 10 main interfaces of the Collections Framework and their associative implementations?

Answer 9

1. Collection<E>
   
   • All of the below
2. List<E>
   
   • ArrayList<E>
   • LinkedList<E>
3. Queue<E>
   
   • ArrayDeque<E>
   • PriorityQueue<E>
   • LinkedList<E>
4. Deque<E>
   
   • ArrayDeque<E>
   • LinkedList<E>
5. Set<E>
   
   • HashSet<E>
   • LinkedHashSet<E> [ordered]
   • TreeSet<E> [sorted]
   • EnumSet<E>
6. SortedSet<E>
   
   • TreeSet<E> [sorted]
7. NavigableSet<E>
   
   • TreeSet<E> [sorted]
8. Map<K,V>
   
   • HashMap<K,V>
   • LinkedHashMap<K,V> [ordered]
   • TreeMap<K,V> [sorted]
   • EnumMap<K,V> [keys are enums]
9. SortedMap<K,V>
   
   • TreeMap<K,V> [sorted]
10. NavigableMap<K,V>
    
    • TreeMap<K,V> [sorted]

Question 10

True or False

When dealing with sorted data structures, its elements must implement Comparable<T> or a Comparator<T> must be provided at creation time

Answer 10

True

Question 11

Are Maps collections?

Answer 11

No

Question 12

What is a Deque?

Answer 12

Double ended queue. Meaning, insertion and deletion can be performed at both the head and tail (FIFO and LIFO)

Question 13

What abstraction and implementation should be used to represent a stack?

Answer 13

Deque and ArrayDeque

Question 14

True or False

Great care must be exercised if mutable objects are used inside collections

Answer 14

True

Question 15

How can a collection be converted to a standard array?

Answer 15

Every collection has a toArray(...) method

        Collection<Integer> c = new ArrayList<>();
        c.add(1);
        c.add(2);
        c.add(3);
        Integer[] arr = c.toArray(new Integer[c.size()]);
        Arrays.stream(arr).forEach(System.out::println);

Question 16

True or False: ArrayList

By increasing its capacity once, at the start, you can prevent several reallocations later. Because reallocations are costly in terms of time, preventing unnecessary ones improves performance

Answer 16

True

Question 17

Can maps be iterated by a for loop?

Answer 17

No because they do not implement the Iterable interface. However, a collection view of a map can be obtained and iterated over by a for loop. Also, maps have a forEach(...) method that can be used directly

Question 18

Code an example of converting a Map<String, Integer> to a List

Answer 18

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
List<Map.Entry<String, Integer>> list = new
ArrayList<>(map.entrySet());

Question 19

True or False

SortedMap<K,V> is sorted by its V

Answer 19

False. SortedMap<K,V> is sorted by its K

Question 20

Shallow or deep copy?

        Collection<Foo> c = new ArrayList<>();
        c.add(new Foo());
        Collection<Foo> c2 = new ArrayList<>(c);

Answer 20

Shallow

Question 21

True or False

Any changes made to a backing collection are visible in the view collection. Correspondingly, any changes made to the view collection, if changes are permitted, are written through to the backing collection

Answer 21

True

Question 22

If an unmodifiable collection contains mutable elements, is the collection considered mutable or immutable?

Answer 22

The collection is considered mutable. For example:

List<User> users = new ArrayList<>();
User user = new User("Gianmarco");
users.add(user);
List<User> unmodifiable = List.copyOf(users);
System.out.println(unmodifiable);
// prints [{ name='Gianmarco'}]
user.setName("Jaime");
System.out.println(unmodifiable); 
// prints [{ name='Jaime'}]

Question 23

When ArrayDeque or LinkedList are used as a stack, from which side are elements pushed and popped?

Answer 23

Elements are pushed and popped from the head of the deque

For example:

1) [ ]
push 1
2) [1]
push 2
3) [2, 1]
pop
4) [1]
pop
5) [ ]

Question 24

What is printed by the following code?

        Collection<Integer> c = new ArrayList<>();
        c.add(1);
        c.add(1);
        c.add(2);
        c.add(3);

        Set<Integer> set = new HashSet<>(c);

        System.out.println(set);

Answer 24

[1, 2, 3]

Question 25

Is it possible to use mutable objects as map keys?

Answer 25

Yes. However, the behavior of a map that uses mutable objects as keys is not specified and should be seriously avoided

Question 26

What is the difference between List.copyOf(collection) and Collections.unmodifiableList(list)?

Answer 26

List.copyOf returns an unmodifiable list and Collections.unmodifiableList(list) returns an unmodifiable view of a list. This means that changes to the list backing the unmodifiable view will be visible in that view. This is not the case with List.copyOf

Question 27

Code an example of converting an array into a collection

Answer 27

Integer[] arr = { 1, 1, 2, 2 };
Set<Integer> set = new HashSet<>();
Collections.addAll(set, arr);
System.out.println(set);