Shuffle algorithm on generic array

Question

I've tried to understand how generics works. I created several implementations sorting algorithms and before sorting i shuffling input array by shuffleArray method in AbstractSorter.java:

public class AbstractSorter<T extends Comparable> {

public void swap(final T[] input, int srcPos, int dstPos) {
    if (dstPos != srcPos) {
        T accum = input[dstPos];
        input[dstPos] = input[srcPos];
        input[srcPos] = accum;

    }
}

public T[] shuffleArray(final T[] inputArray) {
    //        E[] arr = (E[])new Object[INITIAL_ARRAY_LENGTH];
    T[] result = (T[]) new Comparable[inputArray.length];
    System.arraycopy(inputArray, 0, result, 0, inputArray.length);
    int index;
    Random random = new Random();
    for (int i = result.length - 1; i > 0; i--) {
        index = random.nextInt(i + 1);
        if (index != i) {
            swap(result, i, index);
        }
    }
    return result;
}

public boolean more(final T x, final T y) {
    return (x.compareTo(y) > 0);
}

but when i try to use like this:

AbstractSorter<Integer> sortHelper = new AbstractSorter();
Integer[] expResult = new Integer[]{-30, -29, -28, -27 };
Integer[] shuffleArray = sortHelper.shuffleArray(expResult);
System.out.println("Array ="+Arrays.toString(shuffleArray));

it i got exception:

java.lang.ClassCastException: 
[Ljava.lang.Comparable; cannot be cast to [Ljava.lang.Integer;

I don't understand how can i fix shuffle method. Is it possible implement this functionality on arrays or should i migrate to collections?

Thanks in advance!

what is wrong with the inbuilt Shuffle method why not use that ? https://docs.oracle.com/javase/6/docs/api/java/util/Collections.html#shuffle(java.util.List) — StackFlowed, Dec 15 '16 at 16:20
@StackFlowed i use arrays and would'n like to migrate to list. But if there is no other way i will. — John Bl, Dec 15 '16 at 16:24
And `T[] result = (T[]) inputArray.clone();` will resolve the other problem I think. — maraca, Dec 15 '16 at 16:25
@JohnBl you can just do `Arrays.asList(yourValues)` to convert to list. — StackFlowed, Dec 15 '16 at 16:26
@maraca sorry i don't understand where i should put it. could you share an example on gist? — John Bl, Dec 15 '16 at 16:26
@JohnBl first line in `shuffleArray` (not counting the comment). — maraca, Dec 15 '16 at 16:27

score 1 · Answer 1 · edited May 23 '17 at 12:00

1

You're trying to create an array of Comparable, but the expected array is an array of Integer.

You can't cast an array of something to an array of something else, even though the contained objects are parents .

But as you said, we can't easily create an array of generic objects, so I refered to How to create a generic array in Java?

Replace :

T[] result = (T[]) new Comparable[inputArray.length];

with :

final T t = inputArray[0];
T[] result = (T[]) Array.newInstance(t.getClass(), inputArray.length);

edited May 23 '17 at 12:00

Community

1
1

answered Dec 15 '16 at 16:16

Arnaud

16,319
3
24
39

sorry, but i can't compile my class at all - Generic array creation – John Bl Dec 15 '16 at 16:19

score 1 · Accepted Answer · answered Dec 15 '16 at 16:29

The reason you're getting the exception is because you're trying to convert an array of Comparable objects to an array of Integer objects, which is illegal. You can only cast from Integer to Comparable, not the other way around.

This is your problem: T[] result = (T[]) new Comparable[inputArray.length];. Here you're casting a Comparable to T which is an Integer in this case.

Change the lines T[] result = (T[]) new Comparable[inputArray.length]; and System.arraycopy(inputArray, 0, result, 0, inputArray.length); to T[] result = Arrays.copyOf(inputArray, inputArray.length); so your shuffleArray method looks like:

public T[] shuffleArray(final T[] inputArray) {
    T[] result = Arrays.copyOf(inputArray, inputArray.length);
    int index;
    Random random = new Random();
    for (int i = result.length - 1; i > 0; i--) {
        index = random.nextInt(i + 1);
        if (index != i) {
            swap(result, i, index);
        }
    }
    return result;
}

Running the example with:

AbstractSorter<Integer> sortHelper = new AbstractSorter();
Integer[] expResult = new Integer[]{-30, -29, -28, -27};
Integer[] shuffleArray = sortHelper.shuffleArray(expResult);

System.out.println ("Array =" + Arrays.toString(shuffleArray));

Produces the result: Array =[-30, -28, -29, -27]

score 0 · Answer 3 · answered Dec 15 '16 at 16:26

0

Surely you want the following:

public class AbstractSorter<T extends Comparable<T>>

and

T[] result = (T[]) new Comparable<T>[inputArray.length];

and

AbstractSorter<Integer> sortHelper = new AbstractSorter<>();

answered Dec 15 '16 at 16:26

SomeGuy

438
4
8

Shuffle algorithm on generic array

3 Answers3