Generic methods and generic parameters

[O. Ziggy]

static <T> Collection<T> fromArrayToCollection(T[] a, Collection<T> c) {
		for (T o : a) {
		c.add(o); // correct
		}
		
		return c;
	}

I know that Collection<T> is the return type but what does the <T> just after the keyword static do?

Thanks

[Matthew Brown]

That makes it a generic method, which means that T is determined by the way the method is called.

You've probably seen generic classes, where an object is created with a supplied type - like Collection<String>? Well, this is similar, but it means that each call to the method can have a separate generic type. So you could use that method like this:

String[] stringArray = ...;
Integer[] integerArray = ...;
Collection<String> stringCollection = ...;
Collection<Integer> integerCollection = ...;

// Then...

fromArrayToCollection(stringArray, stringCollection);   // T = String
fromArrayToCollection(integerArray, integerCollection); // T = Integer
fromArrayToCollection(stringArray, integerCollection);  // THIS WON'T COMPILE! 

[O. Ziggy]

Ok so T just means that the method is a generic type.

In the following example:

interface Eatable{ public void printMe();}
class Animal { public void printMe(){System.out.println("Animal object");}}
class Dog extends Animal implements Eatable{ public void printMe(){System.out.println("Dog object");}}
class BullTerrier extends Dog{ public void printMe(){System.out.println("BullTerrier object");}}

public class ZiggyTest{
	
	public static void main(String[] args) throws Exception{
				
		Object[] objArray = new Object[]{new Object(), new Object()};
		Collection<Object> objCollection = new ArrayList<Object>();
		
		Animal[] animalArray = new Animal[]{new Animal(),new Animal(),new Animal()};
		Collection<Animal> animalCollection = new ArrayList<Animal>();		
		
		Dog[] dogArray = new Dog[]{new Dog(),new Dog(),new Dog()};
		Collection<Dog> dogCollection = new ArrayList<Dog>();
		
		System.out.println(forArrayToCollection(animalArray,animalCollection).size());
		// System.out.println(forArrayToCollection(dogArray,dogCollection).size());	 #1 Not valid
				
		System.out.println(genericFromArrayToCollection(animalArray,animalCollection).size());
		System.out.println(genericFromArrayToCollection(dogArray,dogCollection).size());  
		
		
		System.out.println(genericFromArrayToCollection(animalArray,objCollection).size()); //#2 
		System.out.println(genericFromArrayToCollection(dogArray,animalCollection).size()); //#3 
 		// System.out.println(genericFromArrayToCollection(objArray,animalCollection).size()); //#4 - Does not compile
				
	}
	
	public static Collection<Animal> forArrayToCollection(Animal[] a, Collection<Animal> c){
		for (Animal o : a){
			c.add(o);
		}
		
		return c;
	}
	
	static <T> Collection<T> genericFromArrayToCollection(T[] a, Collection<T> c) {
		for (T o : a) {
			c.add(o); 
		}
		
		return c;
	}

}

Why does the compiler allow the call to the genericFromArrayToCollection() method only if the declared type of the collection is the parent of the declared type of the array. Why is this please?

When i uncomment the line marked #4 i get the following error

ZiggyTest.java:34: <T>genericFromArrayToCollection(T[],java.util.Collection<T>) in ZiggyTest cannot be applied to (java.lang.Object[],java.util.Collection<Animal>)
                System.out.println(genericFromArrayToCollection(objArray,animalCollection).size()); //#4
                                   ^
1 error

Thanks

[Matthew Brown]

Because in the signature

static <T> Collection<T> genericFromArrayToCollection(T[] a, Collection<T> c)

they have to be the same T for each argument. So there needs to be a T that will satisfy that.

For #4, you've got an Object[] and a Collection<Animal>. There's no T that will work.

#2 is different, though. There you've got an Animal[] and a Collection<Object>. In this case, T can be Object. The difference is that an Animal[] IS-AN Object[], but a Collection<Animal> IS-NOT-A Collection<Object>. In other words:

Object[] array = new Animal[10]; // This will compile
Collection<Object> coll = new HashSet<Animal>(); // This will not

The difference is because with generics the type is not available at runtime (type erasure), which means you need to be stricter to keep type safety. (And this is also why wildcards are needed in generics, whereas they aren't needed with arrays).

[O. Ziggy]

Thanks Mathew i think i got it. I think i didnt understand it before because i didnt know how T was supposed to be applied. I think what you are saying is that the object used in place of T needs to be compatible with every T defined in the 'template'.

In line 2, i am calling the method with Animal[],Collection<Object>. In this case T can be Object because Animal[] is an Object[] and Collection<Object> is a Collection<Object>

In line 4, i am calling the method with Object[], Collection<Animal>. In this case T cannot be Object because even though Object[] is Object[], Collection<Animal> is not Collection<Object>.

Many Thanks

[Matthew Brown]

Yes, I think you've got it