A common frustration with Java is the inability to overload methods when the method signatures differ only by type parameters.

Here’s an example, we’d like to overload a method to take either a List of Strings or a List of Integers. This will not compile, because both methods have the same erasure.

class ErasureExample { public void doSomething ( List < String > strings ) { System . out . println ( "Doing something with a List of Strings " ) ; } public void doSomething ( List < Integer > ints ) { System . out . println ( "Doing something with a List of Integers " ) ; } } class ErasureExample { public void doSomething(List<String> strings) { System.out.println("Doing something with a List of Strings " ); } public void doSomething(List<Integer> ints) { System.out.println("Doing something with a List of Integers " ); } }

If you delete everything in the angle brackets the two methods will be identical, which is prohibited by the spec

public void doSomething ( List <> strings ) public void doSomething ( List <> strings ) public void doSomething(List<> strings) public void doSomething(List<> strings)

As with most Java things – if it’s not working, you’re probably not using enough lambdas. We can make it work with just one extra line of code per method.

class ErasureExample { public interface ListStringRef extends Supplier < List < String >> { } public void doSomething ( ListStringRef strings ) { System . out . println ( "Doing something with a List of Strings " ) ; } public interface ListIntegerRef extends Supplier < List < Integer >> { } public void doSomething ( ListIntegerRef ints ) { System . out . println ( "Doing something with a List of Integers " ) ; } } class ErasureExample { public interface ListStringRef extends Supplier<List<String>> {} public void doSomething(ListStringRef strings) { System.out.println("Doing something with a List of Strings " ); } public interface ListIntegerRef extends Supplier<List<Integer>> {} public void doSomething(ListIntegerRef ints) { System.out.println("Doing something with a List of Integers " ); } }

Now we call call the above as simply as the following, which will print “Doing something with a List of Strings” followed by “Doing something with a List of Integers”

public class Example { public static void main ( String ... args ) { ErasureExample ee = new ErasureExample ( ) ; ee. doSomething ( ( ) -> asList ( "aa" , "b" ) ) ; ee. doSomething ( ( ) -> asList ( 1 , 2 ) ) ; } } public class Example { public static void main(String... args) { ErasureExample ee = new ErasureExample(); ee.doSomething(() -> asList("aa","b")); ee.doSomething(() -> asList(1,2)); } }

Using the wrapped lists inside the method is straightforward. Here we print out the length of each string and print out each integer, doubled. It will cause the above main method to print “2124”.

class ErasureExample { public interface ListStringRef extends Supplier < List < String >> { } public void doSomething ( ListStringRef strings ) { strings. get ( ) . forEach ( str -> System . out . print ( str. length ( ) ) ) ; } public interface ListIntegerRef extends Supplier < List < Integer >> { } public void doSomething ( ListIntegerRef ints ) { ints. get ( ) . forEach ( i -> System . out . print ( i * 2 ) ) ; } } class ErasureExample { public interface ListStringRef extends Supplier<List<String>> {} public void doSomething(ListStringRef strings) { strings.get().forEach(str -> System.out.print(str.length())); } public interface ListIntegerRef extends Supplier<List<Integer>> {} public void doSomething(ListIntegerRef ints) { ints.get().forEach(i -> System.out.print(i * 2)); } }

This works because the methods now have different erasure, in fact the method signatures have no generics in at all. The only additional requirement is prefixing each argument with “() ->” at the callsite, creating a lambda that is equivalent to a Supplier of whatever type your argument is.