Change in method signature erasures in Java 7

This is a small change to Java 7 which was highlighted when another developer started using the Java 7 JDK with some code which was compiling fine in Java 6. When I say "fine", I mean it compiled but Java 6 gave warnings. Here, tell me what is wrong with this code:

package com.meerware;

import java.util.List;

/**
 * Example class of method erasure problems.
 * @author Matt Howlett
 */
public class Concatenator {

    /**
     * @param values is a {@link List} of strings.
     * @return a concatenated string.
     */
    public String concat(List<String> values) {
        final StringBuilder builder = new StringBuilder();
        for (String value : values) {
            builder.append(value);
        }
        return builder.toString();
    }

    /**
     * @param values is a {@link List} of characters.
     * @return a concatenated {@link CharSequence}.
     */
    public CharSequence concat(List<Character> values) {
        final StringBuilder builder = new StringBuilder();
        for (Character value : values) {
            builder.append(value);
        }
        return builder.toString();
    }
}

So what is wrong with this code? Some answers I will accept for bonus points: There are no tests, no code re-use, you should use Guava Joiner and I don't like the name of your class. Answer that may get you a slap in the face: It is written in Java. But the real answer lies in the method signatures.

If you try and compile the above using JDK 6, you should notice two warnings:

Method concat(List<Character>) has the same erasure concat(List<E>) as another method in type Concatenator
Method concat(List<String>) has the same erasure concat(List<E>) as another method in type Concatenator

Now switch to Java JDK 7 and recompile. Suddenly those warnings became errors. Java 7 just became more strict.

So what is the problem? To see why, look at what happens after compile time type erasure kicks in and see what the resulting method signatures look like:

public class Concatenator {
    public Concatenator();
    public String concat(List values);
    public CharSequence concat(List values);
}

See the problem? There are two methods with the same name and same parameter types. You would have gotten away with this in Java 6 but the kids at Oracle have pulled in the reigns on this one in Java 7 and, I think, correctly turned a warning into an error.

The lesson here is pay attention to the warnings, they are there for a reason.