Binary search on arrays/comparator using generics Java

I think you either need a Comparator<Object> or you need an array of E[]. For the latter, I would suggest checking out these two articles:

• How to create a generic array in Java?
• Object array not getting cast to a generic type

Above reading is encouraged.

Option 1: Array.newInstance()

assumes item is never null

Based on what I've read in the aforementioned posts, if you know item will never be null, you could try something like this ...

@SuppressWarnings("unchecked")
private Location findFirst(E item) {
    Location current;
    int closestMatchArray1;
    int closestMatchArray2;

    // Object[] firstItemInArray2 = new Object[numArrayInUse];
    // Object firstItem;

    E[] firstItemInArray2 
            = (E[]) Array.newInstance(item.getClass(), numArrayInUse); 
    E firstItem;

    Comparator<E> comparator = new CompareElement();

    for (int i = 0; i < numArrayInUse; i++) {
        firstItem = (E) topArray[i];
        firstItemInArray2[i] = firstItem;
    }

    closestMatchArray1 = Arrays.binarySearch(firstItemInArray2, item, comparator);

Option 2: Array.newInstance()

requires Class parameter

If you can't guarantee the item will never be null, and you can't provide any special handling for null values, you could force the Class<?> parameter to be passed in, as follows...

@SuppressWarnings("unchecked")
private Location findFirst(E item, Class<E> clazz) {
    Location current;
    int closestMatchArray1;
    int closestMatchArray2;

    // Object[] firstItemInArray2 = new Object[numArrayInUse];
    // Object firstItem;

    E[] firstItemInArray2 
            = (E[]) Array.newInstance(clazz, numArrayInUse); 
    E firstItem;

    Comparator<E> comparator = new CompareElement();

    for (int i = 0; i < numArrayInUse; i++) {
        firstItem = (E) topArray[i];
        firstItemInArray2[i] = firstItem;
    }

    closestMatchArray1 = Arrays.binarySearch(firstItemInArray2, item, comparator);

Option 3: Object Comparator Wrapper

ugly, but it works

Alternatively you can create a Comparator<Object> to wrap your existing Comparator<E>, as follows (I think it's a bit of a hack, but it works consistently for me) ...

    private Location findFirst(E item) {
    Location current;
    int closestMatchArray1;
    int closestMatchArray2;

    Object[] firstItemInArray2 = new Object[numArrayInUse];
    Object firstItem;

    // Comparator<E> comparator = new CompareElement();
    Comparator<Object> comparator = new Comparator<Object>() {
        private final Comparator<E> delegate = new CompareElement();

        @Override
        @SuppressWarnings("unchecked")
        public int compare(Object o1, Object o2) {
            return delegate.compare((E) o1, (E) o2);
        }
    };

    for (int i = 0; i < numArrayInUse; i++) {
        firstItem = topArray[i];
        firstItemInArray2[i] = firstItem;
    }

    closestMatchArray1 = Arrays.binarySearch(firstItemInArray2, item, comparator);

Hope this helps!

You have to pass Class<E> so you may instantiate an array of E. (As <E> is dropped at runtime, E is just Object.)

Class<E> klazz;

E[] firstItemInArray2 = (E[])
        java.lang.reflect.Arrays.newInstance(klazz, numArraysInUse);

You did not declare <E>. You would have to define your CompareElement as follows:

public class CompareElement<E extends Comparable> implements Comparator<E> {
    public int compare(E firstItem, E secondItem) {
        return firstItem.compareTo(secondItem);
    }
}

Then declare it as follows:

Comparator<?> comparator = new CompareElement<?>();

Whereas ? should be the type you want to compare.

Where is your E declared? It seems like some type parameter that is declared in some enclosing class that we can't see. It seems that your CompareElement class is a comparator that compares elements based on their natural ordering (i.e. according to Comparable). If so, then E must have a bound that guarantees that it is able to compare to itself, <E extends Comparable<? super E>>. You can change that bound where E is declared, or, if you want to do it like other people have suggested, to have CompareElement be parameterized separately from the enclosing class, you would do this:

public class CompareElement<E extends Comparable<? super E>> implements Comparator<E> {
  public int compare(E firstItem, E secondItem) {
     return firstItem.compareTo(secondItem);
  }
}

Your first error is because the version of binarySearch you're trying to use, the one with a comparator, has restrictions on the types of the arguments. It is declared like this: static <T> int binarySearch(T[] a, T key, Comparator<? super T> c). So If you have a Comparator<E>, then you will need an E[] as first parameter, whereas you have an Object[]. You have to think of some way to make it E[].

But actually for you you're trying to do you don't need to use a comparator at all. There is a version of the binarySearch method that does not take a comparator, and it already compares elements using their natural ordering.