返回Java中通用类型的数组

Question

I have a class mapper that is supposed to apply any object that implements the Function interface to an array of type D, and return an array of type R.

The problem is that Java does not let me use "new R[]," and so far I've struggled to figure out a way to create an R array from scratch. I currently am attempting to use the Array.newInstance method, but can't find a way to store the class type of R in a Class variable.

public class Mapper {


/**
 * applies passed function to each object of type D in array
 * @param function
 * @param array
 * @return array of type r and length array.length
 */

public static <R, D> R[] map(Function<R, D> function, D[] array)  {

    ArrayList<R> list = new ArrayList<R>();

    //apply function to each variable
    //add rs into object array
    for( int i = 0; i < array.length; i++ ) {

        R r = function.apply( array[i] );
        list.add( r );

    }



    Class<R> clazz = list.get(0).getClass();

    return (R[])Array.newInstance(clazz, list.size()); 

}

}

What can I do properly attain a class value at runtime for the generic type R, or otherwise return the objects in ArrayList as an R[]?

Answer 1

The problem you are facing is related to Java generics type erasure. Since all generic types are erased at runtime, Java has to make trade offs to guarantee type safety.

The problem with generic arrays is that Java would not be able to guarantee that type safety, you can find a good example about this here . In short, generic array creation is not allowed.

To keep most of your original code, you can use Object[] :

public static <D, R> Object[] map(Function<D, R> function, D[] array) {
    List<R> list = new ArrayList<>();
    for (int i = 0; i < array.length; i++) {
        R r = function.apply(array[i]);
        list.add(r);
    }
    return list.toArray(new Object[0]); // no generic array creation allowed!
}

But, that´s why most people stick to lists, as it is way easier to operate with them when generics are involved:

public static <D, R> List<R> map(Function<D, R> function, List<D> array) {
    List<R> list = new ArrayList<>();
    for (D d : array) {
        list.add(function.apply(d));
    }
    return list;
}

And the good part about this is that you can still convert it to an array afterwards when the concrete type is known:

List<String> strings = List.of("Test1", "Test2");
String[] array = map(String::toLowerCase, strings).toArray(new String[0]);

Answer 2

The cleanest way to do this is to simply pass a Class object to the function. Also, it seems like you have the order of the type parameters to Function reversed -- the first type parameter should be the input type and the second should be the result type. Something like this should get you closer to what you want:

public static <R, D> R[] map(Function<D, R> function, D[] array, Class<R> clazz)  {

    R[] result = (R[]) Array.newInstance(clazz, array.length);

    // apply function to each variable and add return value to the result array
    for( int i = 0; i < array.length; i++ ) {
        result[i] = function.apply(array[i]);
    }

    return result;
}

(I'd also suggest reversing the order of the type parameters to your method, to be consistent with the built-in reflection classes like Function .)