Chapter 9 - Collections and Generics

Question 1

Comparable interface belongs in java.lang?

Answer 1

Yes

Question 2

Comparator interface belong in java.lang?

Answer 2

No

Question 3

Comparable does the ordering by multiples params?

Answer 3

No

Question 4

Does the Comparable interface allow sorting of objects using only one natural ordering?

Answer 4

Yes

Question 5

Can the Comparator interface be used to define multiple sorting orders for the same class?

Answer 5

Yes

Question 6

Does implementing Comparable require overriding the compare() method?

Answer 6

No (Comparable requires overriding the compareTo() method, not compare())

Question 7

Can a Comparator be passed to Java’s Collections.sort() method to change the sorting order?

Answer 7

Yes.

Question 8

Is it mandatory for a class to implement Comparable to be sorted using a custom Comparator?

Answer 8

No

Question 9

The List.of() method in Java 17 creates a mutable list.

Answer 9

False. List.of() creates an immutable list.

Question 10

In Java 17, the HashSet class guarantees the order of elements.

Answer 10

False. HashSet does not guarantee any order of elements.

Question 11

The Map.of() method in Java 17 can be used to create an immutable map with up to 10 key-value pairs.

Answer 11

Answer: True.

Question 12

The Collections.emptyList() method returns a thread-safe, immutable empty list.

Answer 12

True.

Question 13

Java 17’s TreeSet uses a Comparator for ordering elements if one is provided during construction.

Answer 13

True.

Question 14

A collection is a group of objects contained in a single object.
If false, why?

Answer 14

True

Question 15

The Java Collections Framework provides classes in java.util for storing and managing collections.
If false, why?

Answer 15

True

Question 16

The List interface allows duplicate entries and provides ordered access to elements via an integer index.
If false, why?

Answer 16

True

Question 17

A Queue orders its elements in a specific order for processing.
If false, why?

Answer 17

True

Question 18

The diamond operator (<>) is a shorthand notation that reduces redundant generic type declarations.
If false, why?

Answer 18

True

Question 19

The Set interface allows duplicate entries.
If false, why?

Answer 19

A Set does not allow duplicate entries.
(False)

Question 20

A Deque is a subinterface of Map that allows access at both ends.
If false, why?

Answer 20

A Deque is a subinterface of Queue, not Map.
(False)

Question 21

A Map allows duplicate keys.
If false, why?

Answer 21

A Map does not allow duplicate keys, only unique ones.

Question 22

The diamond operator can be used in a variable declaration such as List<> list = new ArrayList<Integer>();.
If false, why?</Integer>

Answer 22

The diamond operator cannot be used in a variable declaration, only on the right side of an assignment.

Question 23

The following method compiles: void use(List<> data) {}

Answer 23

If false, why? The diamond operator cannot be used in method parameters or type declarations.
(False)

Question 24

The add() method inserts a new element into the Collection and returns whether it was successful.

Answer 24

True

Question 25

The add() method in a Set always returns true.

Answer 25

(It returns false if the element already exists.)

Question 26

The add() method in a List returns false when adding a duplicate element.

Answer 26

(Lists allow duplicates, so add() returns true.)

Question 27

The remove() method removes a single matching value from the Collection and returns true if successful.

Answer 27

True

Question 28

The remove() method removes all matching elements from the Collection.

Answer 28

(It removes only the first occurrence of a matching element.)

Question 29

The isEmpty() method returns an int representing the number of elements.

Answer 29

(It returns a boolean.)

Question 30

The size() method returns the number of elements in a Collection as an int.

Answer 30

True

Question 31

The clear() method removes only null elements from the Collection.

Answer 31

(It removes all elements.)

Question 32

The contains() method modifies the Collection if the value is present.

Answer 32

(It only checks for existence and does not modify the Collection.)

Question 33

The removeIf() method takes a Consumer as an argument.

Answer 33

(It takes a Predicate.)

Question 34

The forEach() method returns a value after processing all elements.

Answer 34

(It has a void return type.)

Question 35

The forEach() method can only accept a lambda expression as an argument.

Answer 35

(It can also take a method reference.)

Question 36

The removeIf() method removes all elements that match a given condition.

Answer 36

True

Question 37

The contains() method checks whether an element is present using reference equality only.

Answer 37

(It checks using equals().)

Question 38

What does toArray() return when called without arguments on a collection?

Answer 38

It returns an Object[], which cannot be directly assigned to a typed array like String[].

Question 39

How do you correctly convert a ```List``` to a ```String[]```?

Answer 39

By calling ```list.toArray(new String[0])```, which returns a ```String[]```.

Question 40

Why is new String[0] used in toArray(new String[0])?

Answer 40

The array’s type guides the method to return a String[]; the size (0) doesn’t matter because Java resizes it as needed.

Question 41

What is the purpose of the diamond operator (<>) in Java?

Answer 41

It allows the compiler to infer the generic type automatically, reducing verbosity.

Question 42

Can you use a wildcard ? inside the diamond operator when creating an object?

Answer 42

No, a wildcard ? is not allowed inside the diamond operator during instantiation.

Question 43

When is it correct to use a wildcard ? in Java generics?

Answer 43

When declaring a type, such as Comparator, not when instantiating an object.

Question 44

Correct or incorrect: new Comparator() {}

Answer 44

Incorrect — you cannot use ? inside new with generics.

Question 45

How would you correctly instantiate a ```Comparator``` using the diamond operator?

Answer 45

```Comparator c = new Comparator<>() { /* implementation */ };```

Question 46

Why is Comparator c = new Comparator<>() {} not allowed?

Answer 46

Because the type inference expects a specific type, not a wildcard, for instantiation.

Question 47

What does PECS stand for in Java Generics?

Answer 47

PECS = Producer Extends, Consumer Super * Producer = extends (when you only read) * Consumer = super (when you write)

Question 48

When should you use ? extends T?

Answer 48

Use ? extends T when you only need to read values of type T or its subtypes. (You cannot safely add elements.) Example: List

Question 49

Why is ```Comparator``` used instead of ```Comparator```?

Answer 49

Because a Comparator consumes two T values to compare. Using allows comparators of T or any superclass of T, making it more flexible!