How many times do you find yourself creating this code over and over again in tests or even production code?
List<String> stringList = new ArrayList<String>();
stringList.add("some test string");
stringList.add("some other test string");
aMethodThatTakesAListOfStrings(stringList);
Rather than writing this same code over and over again, there is an easier way to create a simple generic list of objects in one method. The following method makes use of two Java 5 features: variable list arguments and generics. Here’s what it looks like:
public static <E> List<E> createArrayList(final E... values) {
   final List<E> list = new ArrayList<E>(values.length);
   for (final E value : values) {
      list.add(value);
   }
   return list;
}
Let me break down what’s happening here.

public static <E> List<E>
this creates a static method and declaring E as a generic type that this method will use and returns a list of that type.

createArrayList(final E... values)
Here a variable length argument array of any type is passed in and “E” is typed to what is passed in. For example if String were passed in, E would be then typed to an array of String, or if BigDecimal were passed in, E would be typed to an array of BigDecimal (The JVM treats variable length arguments as arrays).   Anywhere there is an E, this gets typed to whatever is passed in.

In the rest of the method, an ArrayList of E is created and then the array is looped over and each type is added to the list and the list is then returned.  Here’s the same code as above using our new method:

aMethodThatTakesAListOfStrings(createArrayList("some test string", "some other test string"));

Much nicer isn’t it? That can be used with any object too such as:

aMethodThatTakesAListOfIntegers(createArrayList(1, 2, 3));

The same can be done with any other collection type such as Set, SortedSet, etc. and makes testing and writing code much eaiser.