Documentation
The Java™ Tutorials
Download Ebooks
Download JDK
Search Java Tutorials
Hide TOC
Generics (Updated)
Why Use Generics?
Generic Types
Raw Types
Generic Methods
Bounded Type Parameters
Generic Methods and Bounded Type Parameters
Generics, Inheritance, and Subtypes
Type Inference
Wildcards
Upper Bounded Wildcards
Unbounded Wildcards
Lower Bounded Wildcards
Wildcards and Subtyping
Wildcard Capture and Helper Methods
Guidelines for Wildcard Use
Type Erasure
Erasure of Generic Types
Erasure of Generic Methods
Effects of Type Erasure and Bridge Methods
Non-Reifiable Types
Restrictions on Generics
Questions and Exercises
Trail: Learning the Java Language
Lesson: Generics (Updated)
« Previous • Trail • Next »

# 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.

Check your answers.
« Previous • Trail • Next »

Previous page: Restrictions on Generics
Next page: Packages