Generics

What is the main benefit of ArrayList<String> over a pre-generics ArrayList that stores Object?

What happens when this code runs?

List list = new ArrayList();
list.add("7");
list.add(8);
int total = 0;
for (Object o : list) total += (Integer) o;
System.out.println(total);

Which declaration compiles?

Which method header is a correct static generic method?

Which assignment compiles?

What is the result of running this code?

Object[] arr = new String[2];
arr[0] = "ok";
System.out.println("stored");
arr[1] = 1;
System.out.println("done");

What is printed?

static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}

// ...
System.out.println(max(3, 7) + " " + max("pear", "apple") + " " + max("Zoo", "apple"));

Using the max method of the previous question, what happens with System.out.println(max(3, "x"));?

By convention, what do the type parameters in Map<K, V> and List<E> stand for?

Given List<? extends Number> nums = new ArrayList<Integer>();, which statement compiles?

Given List<? super Integer> sink = new ArrayList<Number>();, which statement does not compile?

A method average(... values) only reads numbers from a list and must accept a List<Integer>, a List<Double> and a List<Number>. Which parameter type is best?

With the method below and the lists List<Integer> ints, List<Number> nums, List<Object> objs, which call does not compile?

static <T> void copy(List<? super T> dst, List<? extends T> src) {
    for (T t : src) dst.add(t);
}

What is printed?

static double sum(List<? extends Number> xs) {
    double s = 0;
    for (Number n : xs) s += n.doubleValue();
    return s;
}

// ...
System.out.println(sum(Arrays.asList(1, 2.5, 3)));

What does this print?

System.out.println(new ArrayList<String>().getClass()
                   == new ArrayList<Integer>().getClass());

Which line compiles inside class Box<T> { ... }?

Inside static <T> boolean test(Object o) { return ... ; }, which expression compiles under Java 8?

Does this class compile?

class Printer {
    void print(List<String> a)  { System.out.println("strings"); }
    void print(List<Integer> a) { System.out.println("integers"); }
}

What happens when this code runs?

List<String> s = new ArrayList<>();
List raw = s;
raw.add(42);
System.out.println("size " + s.size());
String x = s.get(0);
System.out.println("got " + x);

Which type-parameter declaration compiles?

What is printed?

class Pair<K, V> {
    private final K key;
    private final V value;
    Pair(K key, V value) { this.key = key; this.value = value; }
    K getKey()   { return key; }
    V getValue() { return value; }
    Pair<V, K> swap() { return new Pair<>(value, key); }
}

// in main:
Pair<String, Integer> p = new Pair<>("a", 1);
System.out.println(p.swap().getKey() + 10);
System.out.println(p.getKey() + p.getValue() + 10);

What is printed?

List<Integer> list = new ArrayList<>(Arrays.asList(10, 1, 20, 1));
list.remove(1);
System.out.println(list);
list.remove(Integer.valueOf(1));
System.out.println(list);

Given static <T> T pick(T a, T b) { return b; }, which statement compiles?

In class SortedBox<T extends Comparable<T>> { private T item; ... }, what is the type of the field item after erasure (as seen through reflection at run time)?

Explain the PECS rule. Using the signature static <T> void copy(List<? super T> dst, List<? extends T> src), explain why src uses extends and dst uses super, and what would be lost if both parameters were declared List<T>.

What is type erasure? Give three restrictions that it imposes on generic code, with a one-line reason for each.

Arrays in Java are covariant (String[] is an Object[]) but generic types are invariant (List<String> is not a List<Object>). Write a two-line example that shows what would go wrong if List<String> were a subtype of List<Object>, and explain how arrays protect themselves instead.

What is a raw type? Why should you avoid raw types in new code, and what should you write instead when you really do not care about the element type?

Write a static generic method countGreater that receives an array of any comparable type and a value x of the same type, and returns how many elements are strictly greater than x. For example, countGreater(new Integer[]{5, 1, 9, 5, 7}, 5) returns 2 and countGreater(new String[]{"kiwi", "apple", "pear"}, "fig") returns 2.

Write two static methods that follow the PECS rule:

• sumAll, which returns the sum (as a double) of any collection of numbers — it must accept a List<Integer>, a Set<Double> or a List<Number>;
• fillWith, which adds the integers 1, 2, …, n to a list — it must accept a List<Integer>, a List<Number> or a List<Object>.