Java generic methods difference between two arrays

Question

I am trying to write a method that will find the difference between elements of two arrays of the same length and here is what I did until now:

  public static <T extends Object> T method(T[] array,T[] array1){
      T[]difference;
      difference = new T[array.length]; //error :generic array creation
      for(int i=0;i<array.length;i++){
          difference[i]=array[i]-array1[i]; //error:bad operand types for binary operator

      }
      return (T)difference;
  }   

but it constantly returns to me a message that i wrote next to the line of the code that it refers to

Answer 1

There are two problems with your code:

1. Java doesn't support generic array creation. You can get round this by creating an array of Objects and then casting.

2. The bigger problem is that java doesn't support operator overloading, and subtraction (i.e. -) is only supported by primitive types. This is compouded by the fact that generics doesn't support primitive types, which makes what you're trying to do impossible on its own.

To get round these problems, you'd need to do a number of things:

1. Don't use primitives, but you can used boxed types instead (so instead of int you'd use Integer, etc.).

2. You need to tell your function how to find the difference between two objects of the required type. You can achieve this by defining a 'Subtractor' interface.

I'd also suggest using lists instead of arrays, as these handle generics much more nicely. You can easily convert between lists and arrays afterwards if needed.

So, as a skeleton of a solution, here's what I'd propose:

1. Define a generic interface for finding differences:

   interface Subtractor<T> {
       T subtract(T a, T b);
   }
   

2. Rewrite your method to use lists, and to take a subtractor as an argument:

   public static <T> List<T> difference(
           List<? extends T> listA, List<? extends T> listB, Subtractor<T> subtractor) {
       int resultSize = Math.min(listA.size(), listB.size());
       List<T> result = new ArrayList<>(resultSize);
       for(int i=0; i<resultSize; ++i) {
           result.add(subtractor.subtract(listA.get(i), listB.get(i)));
       }
       return result;
   }
   

3. Define subtractor implementations for the types you want to be able to use the method with:

   class IntSubtractor implements Subtractor<Integer> {
       @Override
       Integer subtract(Integer a, Integer b) {
           return Integer.valueOf(a.intValue() - b.intValue());
       }
   }
   

4. Use your method. You can use Arrays.asList for turning arrays into lists, but you can't use arrays of primitives unfortunately.

   Integer[] a = new Integer[]{5,6,7,8};
   Integer[] b = new Integer[]{1,2,3,4};
   Integer[] c = difference(Arrays.asList(a), Arrays.asList(b), new IntSubtractor())
           .toArray(new Integer[4]);