What does the program print?

Set<Integer> a =
    new TreeSet<>(List.of(1, 2, 3, 4));
Set<Integer> b =
    new TreeSet<>(List.of(3, 4, 5));
Set<Integer> both = a;
both.retainAll(b);
System.out.println(a + " " + both.size());

Correct: C. both = a makes no copy; both variables refer to the same object. Because retainAll works in place, a also becomes [3, 4]. Option A assumes a was copied; to take the intersection without changing a, you need new TreeSet<>(a).

What does the program print?

Set<String> l = new LinkedHashSet<>();
Set<String> t = new TreeSet<>();
for (String s : List.of("plum", "apple",
                         "cherry", "apple")) {
  l.add(s);  t.add(s);
}
System.out.println(l + " " + t);

Correct: A. LinkedHashSet keeps insertion order (a hash table plus a doubly linked list); TreeSet is a red-black tree and iterates alphabetically. B is wrong: the second "apple" is added to neither set, because a set holds no duplicates.

The Person class has fields firstName and lastName. What does the program print?

TreeSet<Person> s = new TreeSet<>(
    Comparator.comparing((Person p) -> p.lastName));
s.add(new Person("Ann", "Smith"));
s.add(new Person("Alice", "Smith"));
s.add(new Person("Ben", "Jones"));
System.out.println(s.size());

Correct: D. TreeSet decides equality with compare(a, b) == 0, so "Alice Smith" counts as the same as "Ann Smith" and is not added (add returns false). Option A assumes equals is consulted. The fix is .thenComparing(p -> p.firstName): the ordering must be consistent with equals. Since a Comparator is supplied, Comparable is not needed (C is wrong).

What happens if remove always writes counts.put(e, c - 1); instead of if (c == 1) counts.remove(e); else counts.put(e, c - 1);?

boolean remove(E e) {
  Integer c = counts.get(e);
  if (c == null) return false;
  counts.put(e, c - 1);   // the change
  n--;
  return true;
}

Correct: C. If the entry isn't deleted when its count reaches 0, the c == null check no longer detects "element absent": a second remove sets the count to −1 and corrupts size, and the number of distinct elements (counts.size()) grows too. A is a distractor: after the first remove, count really does return 0; the bug only shows up in later operations.

The equals and hashCode methods of class Point use the fields x and y. What does the program print?

Set<Point> s = new HashSet<>();
Point p = new Point(1, 2);
s.add(p);
p.x = 5;
System.out.println(s.contains(p) + " "
    + s.size());

Correct: A. p was placed in the bucket for the hash of (1, 2). When x changes, so does the hash code; contains(p) looks in the bucket of the new hash and doesn't find p. The element itself stays in the old bucket, so size remains 1. B is a distractor ("it's the same object"), but a HashSet finds objects through their bucket. Never change the fields that go into the hash of an object stored in a set.