如何将通用ArrayList强制转换为通用数组

Question

When I call printArray in my pvsm, the error I keep receiving is:

Exception in thread "main" java.lang.ClassCastException: 
    java.base/[Ljava.lang.Object; cannot be cast to java.base/[Ljava.lang.Integer

I know the problem is with the R[] result = (R[]) list.toArray() . I have no idea how to convert the ArrayList to an array and cast it to a generic at the same time. Note I cannot change the parameters of the function map or add any new functions.

public class Homework2 {

    public static void main(String[] args){
        Function<Integer,Integer> function = new CalculateSuccessor();
        Double[] d= {2.0,4.0,8.0};
        Integer[] i= {2,4,8};
        printArray(map(function,i));
    }

    @SuppressWarnings("unchecked")
    public static <R,D> R[] map(Function<R,D> function, D[] array){
        ArrayList<R> list = new ArrayList<>();
        for (D element: array){
           list.add(function.apply(element));
        }


        // THIS LINE OF DAMN CODE
        R[] result = (R[]) list.toArray();

        return result;
    }

    public static <R> void printArray(R[] array){
        System.out.print("{ ");
        for (R element: array){
            System.out.print(element + ", ");
        }
        System.out.print("}");
    }

    public static class CalculateSuccessor implements Function<Integer,Integer> {
        @Override
        public Integer apply(Integer parameter) {
            return parameter * 2;
        }
    } //End CalcSuc

} //End Homework2

In another class I have

public interface Function<R,D> {
     public R apply(D parameter);
}

which you need for the function.apply. My professor insisted we use this instead of importing Function.

Answer 1

Part one, you need the Class<R> in order to dynamically create an array R[] . I would prefer Arrays.toString over implementing my own version of that. I also needed a Function<D, R> (not a Function<R, D> ). But making those changes like

public static void main(String[] args) {
    Function<Integer, Integer> function = new CalculateSuccessor();
    Double[] d = { 2.0, 4.0, 8.0 };
    Integer[] i = { 2, 4, 8 };
    System.out.println(Arrays.toString(map(Integer.class, function, i)));
}

public static <R, D> R[] map(Class<R> cls, Function<D, R> function, D[] array) {
    ArrayList<R> list = new ArrayList<>();
    for (D element : array) {
        list.add(function.apply(element));
    }
    return list.toArray((R[]) Array.newInstance(cls, list.size()));
}

I get

[4, 8, 16]

Answer 2

You can extract the type information from the Function<D,R> because you implemented it with an actual class. So together with @Elliott Frisch answer.

public static <R, D> R[] map(Function<D, R> function, D[] array) {
    ArrayList<R> list = new ArrayList<>();
    for (D element : array) {
        list.add(function.apply(element));
    }
    Class<?> componentClass = extractReturnType(function)
    return list.toArray((R[]) Array.newInstance(componentClass, list.size()));
}

private static Class<?> extractReturnType(Function<?, ?> function) {
    Type[] interfaces = function.getClass().getGenericInterfaces();
    for(Type iface:interfaces) {
        if (iface instanceof ParameterizedType && Function.class.equals(((ParameterizedType) iface).getRawType())) {
            return (Class<?>) ((ParameterizedType) iface).getActualTypeArguments()[1];
        }
    }
    throw new IllegalArgumentException("Unable to extract type information");
}