Question

I am given the Pair.java class and have to implement the PairTools.java class.

Pair.java

import java.util.Objects;

public class Pair<A, B> {

    public final A a;
    public final B b;

    public Pair(A a, B b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public String toString() {
        // appending things to the empty string prevents us from having to worry about null
        // and calling toString explicitly, Objects.toString(a) + " " + Objects.toString(b)
        // would also work
        return "" + a + " " + b;
    }

    @Override
    public boolean equals(Object obj) {
        // `obj instanceof Pair` will automatically return false if obj is null
        if (!(obj instanceof Pair)) {
            return false;
        }

        // some warnings with generics are unavoidable
        @SuppressWarnings("unchecked")
        Pair<A, B> p = (Pair<A, B>) obj;

        // we use Objects.equals() to handle nulls easily
        return Objects.equals(a, p.a) && Objects.equals(b, p.b);
    }

    @Override
    public int hashCode() {
        // we use Objects.hashCode() to handle nulls easily, 
        // the operation ^ is XOR, not exponentiation
        return Objects.hashCode(a) ^ Objects.hashCode(b);
    }
}

In PairTools.java I have to implement the following method:

public class PairTools {

    /**
     * this is how you can use wildcards in generics
     * 
     * @param pair (assume never null)
     * @return a pair containing two references to a of the given pair
     */
    public static <A> Pair<A, A> copyA(Pair<A, ?> pair) {
        return null;
    }

}

I don’t understand the implementation. I need an explanation.

Answer 1

A possible implementation can look like this.

public class PairTools {

    /**
     * this is how you can use wildcards in generics
     * 
     * @param pair (assume never null)
     * @return a pair containing two references to a of the given pair
     */
    public static <A> Pair<A, A> copyA(Pair<A, ?> pair) {
        return new Pair<A, A>(pair.a, pair.a);
    }

}

This ignores the b value of the given pair and returns a new pair with two references to a.

You cannot simply do this

return new Pair<A, A>(pair.a, pair.b);

because you have to return a Pair<A, A>. You get a Pair<A, ?> as parameter so you can only be sure that the first value of the given pair is of type A. You don’t know the type of pair.b.