Lately I came across some differences between the Eclipse Java compiler and the Sun Java compiler. I already experienced them in another case but both have to do with how the compiler handles generics. In most of my projects I am coding in Eclipse and building the product using ant – and the Sun Java compiler. In these cases everything works fine inside Eclipse which means the code compiles and runs but the ant build process fails. Here is some example code:

import java.util.ArrayList;
import java.util.Collection;

public class CompCheck {

  private Collection<Class> getClasses() {
    final ArrayList<Class> list = new ArrayList<Class>();
    list.add(String.class);
    list.add(Integer.class);
    return list;
  }

  public static void main(final String[] args) {
    final CompCheck compCheck = new CompCheck();
    final Collection<Class<?>> classes = new ArrayList<Class<?>>();
    classes.addAll((Collection<? extends Class<?>>)
	                                 compCheck.getClasses());
    for (final Class<?> clazz : classes) {
      System.out.println(clazz);
    }
  }

}

In my case the getClasses method was provided by a library and so I could not change it. The cast Collection<? extends Class<?>> was added by the Eclipse Quick fix feature and it worked in Eclipse. But the ant build script failed with the following message:

[javac] D:\workspace\compcheck\src\CompCheck.java:16: inconvertible types
[javac] found   : java.util.Collection<java.lang.Class>
[javac] required: java.util.Collection<? extends java.lang.Class<?>>
[javac]         classes.addAll((Collection<? extends Class<?>>)
                                         compCheck.getClasses());
[javac]                                                                                     ^
[javac] 1 error

Who is to blame? Is it the Eclipse compiler or the Sun Compiler? I had to change my code back to the following which produces a lot of warnings:

import java.util.ArrayList;
import java.util.Collection;

public class CompCheck {

  private Collection<Class> getClasses() {
    final ArrayList<Class> list = new ArrayList<Class>();
    list.add(String.class);
    list.add(Integer.class);
    return list;
  }

  public static void main(final String[] args) {
    final CompCheck compCheck = new CompCheck();
    final Collection<Class> classes = new ArrayList<Class>();
    classes.addAll(compCheck.getClasses());
    for (final Class<?> clazz : classes) {
      System.out.println(clazz);
    }
  }

}

This piece of code compiles with both compilers. The best solution would be the following:

import java.util.ArrayList;
import java.util.Collection;

public class CompCheck {

  private Collection<Class<?>> getClasses() {
    final ArrayList<Class<?>> list = new ArrayList<Class<?>>();
    list.add(String.class);
    list.add(Integer.class);
    return list;
  }

  public static void main(final String[] args) {
    final CompCheck compCheck = new CompCheck();
    final Collection<Class<?>> classes = new ArrayList<Class<?>>();
    classes.addAll(compCheck.getClasses());
    for (final Class<?> clazz : classes) {
      System.out.println(clazz);
    }
  }

}

This one compiles with both compilers and produces zero warnings in Eclipse. I had to read the Java 5 generics tutorial again to understand what the wildcard generic really means but I did not find any information on the web about this difference between the compilers.