Questions and Exercises: Generics

1. Write a generic method to count the number of elements in a collection that have a specific property (for example, odd integers, prime numbers, palindromes).
   
   
2. Will the following class compile? If not, why?

   public final class Algorithm {
       public static <T> T max(T x, T y) {
           return x > y ? x : y;
       }
   }
   

3. Write a generic method to exchange the positions of two different elements in an array.
   
   
4. If the compiler erases all type parameters at compile time, why should you use generics?
   
   
5. What is the following class converted to after type erasure?

   public class Pair<K, V> {
   
       public Pair(K key, V value) {
           this.key = key;
           this.value = value;
       }
   
       public K getKey(); { return key; }
       public V getValue(); { return value; }
   
       public void setKey(K key)     { this.key = key; }
       public void setValue(V value) { this.value = value; }
   
       private K key;
       private V value;
   }
   

6. What is the following method converted to after type erasure?

   public static <T extends Comparable<T>>
       int findFirstGreaterThan(T[] at, T elem) {
       // ...
   }
   

7. Will the following method compile? If not, why?

   public static void print(List<? extends Number> list) {
       for (Number n : list)
           System.out.print(n + " ");
       System.out.println();
   }
   

8. Write a generic method to find the maximal element in the range [begin, end) of a list.
   
   
9. Will the following class compile? If not, why?

   public class Singleton<T> {
   
       public static T getInstance() {
           if (instance == null)
               instance = new Singleton<T>();
   
           return instance;
       }
   
       private static T instance = null;
   }
   

10. Given the following classes:

    class Shape { /* ... */ }
    class Circle extends Shape { /* ... */ }
    class Rectangle extends Shape { /* ... */ }
    
    class Node<T> { /* ... */ }
    

    Will the following code compile? If not, why?

    Node<Circle> nc = new Node<>();
    Node<Shape>  ns = nc;
    

11. Consider this class:

    class Node<T> implements Comparable<T> {
        public int compareTo(T obj) { /* ... */ }
        // ...
    }
    

    Will the following code compile? If not, why?

    Node<String> node = new Node<>();
    Comparable<String> comp = node;
    

12. How do you invoke the following method to find the first integer in a list that is relatively prime to a list of specified integers?

    public static <T>
        int findFirst(List<T> list, int begin, int end, UnaryPredicate<T> p)
    

    Note that two integers a and b are relatively prime if gcd(a, b) = 1, where gcd is short for greatest common divisor.