"Name Clash: Method in Two Classes Have Same Erasure, Yet Neither Over-..."

Question

Ok, I'm getting this message when trying to compile the classes below: "FileUtils.java:1117: name clash: add(E) in java.util.ArrayList<java.util.LinkedList<F>> and add(T) in gov.sandia.gajanik.util.Addable<F> have the same erasure, yet neither overrides the other"
The funny thing is, they actually don't have the same erasure, from what I can see. In short, I have a class
class DuplicatesArrayList<F extends File> extends ArrayList<LinkedList<F>> implements Addable<F>Addable<T> has a method
public boolean add(T addMe);and, from the javadoc for jdk1.6.0, ArrayList<E>has a method
public boolean add(E e);But, note how ArrayList has the type parameter LinkedList<F> and Addable has the type parameter F. Given that, the erasures should be
public boolean add(LinkedList e);//Erasure of LinkedList<F>
public boolean add(File addMe);  //Erasure of FAm I missing something? Is it just the end of the day and my brain isn't working right? Help!

Answer 1

Actually, the ArrayList extension is the most critical part. The class I'm trying to make really is an ArrayList that has files added to it, but stores them in LinkedList (the context doing the adding decides when to delimit the files in LinkedLists). I came to this solution because I tried to designed the method that's actually using the ArrayList the take anything that it can "add" Files to and separate related groups of files. This way it can either use a collection-type class (what you've seen here) or a class that handles the files differently (I have one that prints them to System.out instead). I could require a collection, but then the method that is calling "add" also has to specify exactly how it groups related files together (which is less flexible), and callers must implement all the methods specified by the Collection interface (or have them throw something like an UnsupportedOperationException for everthing except "add"), even though all I need is "add".
I probably could make my own inheritance tree that would simply be a copy of that in java.util, starting at AbstractList. But I have qualms about copying Sun's source code (which is essentially what I would do) and then just add the few methods I need to their collection classes.
I'm interested to know how you would implement such a solution, if you would be kind enough to show me. Here's what I have:
* An interface that specifies an object that can have things added to (and thus
* processed by) it.</p>
* @param <T> The type processed by this {@code Addable}
public interface Addable<T> {
     * Ensures that this {@code Addable} takes appropriate action on the
     * specified object</p>
     * @param addMe The object to operate on
     * @return Whether or not the operation succeeded
    public boolean add(T addMe);
     * Ensures that this {@code Addable} takes appropriate action on all the
     * items returned by the iterator of the specified iterable object</p>
     * @param itr The object to get items from
     * @return The number of items successfully proccessed
    public int addAll(Iterable<T> itr);
    public static final class DefaultBehavior {
         * Ensures that this {@code Addable} takes appropriate action on all the
         * items returned by the iterator of the specified iterable object</p>
         * @param <T> The type contained by the iterator and target
         * @param me The target to add to (typically the caller)
         * @param itr The object to get items from
         * @return The number of items successfully proccessed
        public static final <T> int addAll(final Addable<T> me,
                final Iterable<T> itr) {
            int totalAdded = 0;
            if (itr instanceof List) {
                for (T element : (List<T>)itr)
                    if (me.add(element))
                        totalAdded++;
            } else {
                for (T element : itr)
                    if (me.add(element))
                        totalAdded++;
            return totalAdded;
}I would make Addable an abstract class with that default implementation for addAll, but alas, Java only allows single class inheritance, and I can't even make that DefaultBehavior class protected (which would make more sense than public).
* @param <T> {@inheritDoc}
public interface GroupingAddable<T> extends Addable<T> {
     * Indicates the items added since the last call to this method should be
     * associated under the given combination of keys</p>
     * @param keys The keys that identify this group
     * @return The number of items that were added to the group
    public int group(Object... keys);
     * Supplies some default implementations of the methods in this interface
     * </p><p>
     * This member would be more suited to {@code static protected} access, but
     * the JLS does not allow protected members of interfaces.<p>
    public static class DefaultBehavior {
         * Ensures that this {@code Addable} takes appropriate action on all the
         * items returned by the iterator of the specified iterable object</p>
         * @param <F> The type contained by the iterator and target
         * @param me The target to add to (typically the caller)
         * @param itr The object to get items from
         * @return The number of items successfully proccessed
        public static final <F extends File> int addAll(
                final DuplicatesStore<F> me,
                final Iterable<F> itr) {
            int totalAdded = 0;
            if (itr instanceof List) {
                for (F element : (List<F>)itr)
                    if (me.add(element))
                        totalAdded++;
            } else {
                for (F element : itr)
                    if (me.add(element))
                        totalAdded++;
            return totalAdded;
         * Wraps a given {@code DuplicatesStore} in a
         * {@link GroupingAddable} that passes calls to the given store</p>
         * @param <F> The type accepted by the given store
         * @param store The object to wrap
         * @return An {@code Addable} wrapper for the given store
        public static final <F extends File> GroupingAddable<F>
                asGroupingAddable(final DuplicatesStore<F> store) {
            return new GroupingAddable<F>() {
                public int group(Object... keys) {
                    return store.group(keys);
                public boolean add(F addMe) {
                    return store.add(addMe);
                public int addAll(Iterable<F> itr) {
                    return store.addAll(itr);
        protected DefaultBehavior() {
            throw new UnsupportedOperationException("Class has no instance members");
}Note that the following class exposes the same public API as GroupingAddable, but the aforementioned name clash requires this copy
public interface DuplicatesStore<F extends File> {
     * Adds a duplicate to the current group of duplicates</p>
     * @param addMe The duplicate to add to the current group of duplicates
     * @return true if the add operation succeeded, false otherwise
    public boolean add(F addMe);
     * Ensures that this {@code Addable} takes appropriate action on all the
     * items returned by the iterator of the specified iterable object</p>
     * @param itr The object to get items from
     * @return The number of items successfully proccessed
    public int addAll(Iterable<F> itr);
     * Marks the previous file {@code add}ed as the last of a group of files
     * that are duplicates.</p>
     * @param keys Ignored
     * @return The number of files in the group that was just marked
    public int group(Object... keys);
     * Supplies some default implementations of the methods in this interface
     * </p><p>
     * This member would be more suited to {@code static protected} access, but
     * the JLS does not allow protected members of interfaces.<p>
    public static class DefaultBehavior {
         * Ensures that this {@code Addable} takes appropriate action on all the
         * items returned by the iterator of the specified iterable object</p>
         * @param <F> The type contained by the iterator and target
         * @param me The target to add to (typically the caller)
         * @param itr The object to get items from
         * @return The number of items successfully proccessed
        public static final <F extends File> int addAll(
                final DuplicatesStore<F> me,
                final Iterable<F> itr) {
            int totalAdded = 0;
            if (itr instanceof List) {
                for (F element : (List<F>)itr)
                    if (me.add(element))
                        totalAdded++;
            } else {
                for (F element : itr)
                    if (me.add(element))
                        totalAdded++;
            return totalAdded;
         * Wraps a given {@code DuplicatesStore} in a
         * {@link GroupingAddable} that passes calls to the given store</p>
         * @param <F> The type accepted by the given store
         * @param store The object to wrap
         * @return An {@code Addable} wrapper for the given store
        public static final <F extends File> GroupingAddable<F>
                asGroupingAddable(final DuplicatesStore<F> store) {
            return new GroupingAddable<F>() {
                public int group(Object... keys) {
                    return store.group(keys);
                public boolean add(F addMe) {
                    return store.add(addMe);
                public int addAll(Iterable<F> itr) {
                    return store.addAll(itr);
        protected DefaultBehavior() {
            throw new UnsupportedOperationException("Class has no instance members");
}And we're getting closer to an actual implementation. I have both a LinkedList and ArrayList implementation of this interface, but I'm only posting the ArrayList. This would also be a good candidate for an abstract class, but then I wouldn' be able to inherit from java.util classes. The methods specified by this interface have the same implenation in both the ArrayList and LinkedList versions.
* A list of {@link LinkedList} specically for storing and grouping
* duplicate files</p>
* @param <F> The type contained by this list
public interface DuplicatesList<F extends File> extends List<LinkedList<F>>,
        DuplicatesStore<F> {
     * Adds a duplicate to the current group of duplicates</p>
     * @param file The duplicate to add to the current group of duplicates
     * @return true if the add operation succeeded, false otherwise
    public boolean add(F file);
     * Marks the previous file {@code add}ed as the last of a group of files
     * that are duplicates.</p>
     * @param keys Ignored
     * @return The number of files in the group that was just marked
    public int group(Object... keys);
     * Retreives the number of files added to this collection.</p>
     * <p>
     * This is not the number of collections contained immediately within
     * this collection, but the count of all files contained in this
     * collection's collections</p>
     * @return The count of files contained
    public int records();
     * {@inheritDoc}
     * @param <F> The type contained by the object that contains an instance of
     *      this class
    public class DefaultBehavior<F extends File> extends
            DuplicatesStore.DefaultBehavior {
         * Temporary storage for duplicate files until {@code group} is called,
         * at which point this variable is added to {@code this}, then cleared
        protected LinkedList<F> innerStore = new LinkedList<F>();
        /** The number of files added to {@code this} */
        protected int records = 0;
        protected DefaultBehavior() {
         * Adds a duplicate to the current group of duplicates</p>
         * @param me Ignored
         * @param file The duplicate to add to the current group of duplicates
         * @return true if the add operation succeeded, false otherwise
        public final boolean add(DuplicatesList<F> me, final F file) {
            records++;
            return innerStore.add(file);
         * Marks the previous file {@code add}ed as the last of a group of files
         * that are duplicates.</p>
         * This particular implementation will remove the first element added to
         * the group, sort the group according to its natural order, add the
         * element that was removed to the beginning of the group, then add the
         * linked list representing the group to this {@code LinkedList}.</p>
         * @param me The object to operate on (typically "this")
         * @param keys Ignored
         * @return The number of files in the group that was just marked
        public final int group(final DuplicatesList<F> me,
                final Object... keys) {
            int innerSize = innerStore.size();
            if (innerSize > 1) {
                F base = innerStore.pop();
                sort(innerStore);
                innerStore.addLast(base);
            if (me.add(innerStore)) {
                innerStore = new LinkedList<F>();
                return innerSize;
            } else return -1;
}And the implentation
* An {@code ArrayList} implementation of {@link DuplicatesList}</p>
* <p>
* Groups are contained in {@code LinkedList}s stored within this
* {@code ArrayList}.</p>
* @param <F> {@inheritDoc}
public class DuplicatesArrayList<F extends File>
        extends ArrayList<LinkedList<F>> implements DuplicatesList<F> {
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator</p>
     * <p>
     * (Documentation copied from {@link ArrayList})</p>
     * @param addMe The collection whose elements are to be placed into this
     *      list
     * @throws NullPointerException If the specified collection is null
    protected DuplicatesArrayList(Collection<? extends LinkedList<F>> addMe) {
        super(addMe);
        def.records = super.size();
     * {@inheritDoc}
     * @param itr {@inheritDoc}
     * @return {@inheritDoc}
    @SuppressWarnings("static-access")
    public int addAll(Iterable<F> itr) {
        return def.addAll(this, itr);
     * {@inheritDoc}
     * @param file {@inheritDoc}
     * @return {@inheritDoc}
    public boolean add(F file) {
        return def.add(this, file);
     * {@inheritDoc}
     * <p>
     * This particular implementation will remove the first element added to
     * the group, sort the group according to its natural order, add the
     * element that was removed to the beginning of the group, then add the
     * linked list representing the group to this {@code ArrayList}.</p>
     * @param keys {@inheritDoc}
     * @return {@inheritDoc}
    public int group(Object... keys) {
        return def.group(this, keys);
     * {@inheritDoc}
     * @return {@inheritDoc}
    public int records() {
        return def.records;
}Here's an alternative to the collection-type DuplicatesStore I just showed you
* An object that prints duplicates as they are grouped</p>
* <p>
* The first file added to the group is appended to the {@link Appendable}
* provided at construction.  If specified at construction time, the system-
* specific path separator (as specified by {@link File#pathSeparator} then
* the file's length are also appended.  Then the previous text is followed
* by the system line separator (as specified by
* {@code System.getProperty("line.separator")}).  Any files
* that were added after it are appended in the same way, but are preceded
* by a horizontal tab, are not followed by their length.</p>
public class PrintingDuplicatesStore
        implements DuplicatesStore<File>, GroupingAddable<File> {
     * The system-specific line separator
    public static final String LINE_SEPARATOR =
            System.getProperty("line.separator");
     * The exception that contains any uncaught {@code Throwable}s thrown
     * during a call to {@code group} or {@code add}
    public static class AppendException extends RuntimeException {
         * Creates a new AppendException with it's cause set to the given
         * {@code Throwable} and messages set to the parameter's messages
         * @param cause The {@code Throwable} that caused this
         *      {@code AppendException} to be thrown
        public AppendException(final Throwable cause) {
            super(cause);
         * {@inheritDoc}
         * @return {@inheritDoc}
        public String getMessage() {
            return getCause().getMessage();
         * {@inheritDoc}
         * @return {@inheritDoc}
        public String getLocalizedMessage() {
            return getCause().getMessage();
     * This object to send output to
    protected Appendable out;
     * Whether this object is appending unique files (files in a group that
     * was only added to once) to the output
    protected boolean printingUniques;
     * Whether this object is appending files that have copies (groups with
     * more than one file) to the output
    protected boolean printingCopies;
     * Whether this object appends a path separator and the file's length
     * to the output after the first file of a group is appended
    protected boolean printingLength;
    /**The first file addded to the current group (null if the group is new)
    protected File currentBase = null;
    /** The number of files in the current group*/
    protected int groupSize = 0;
     * Creates a new instance whose behavior is specified by the given
     * parameters</p>
     * @param out The output to append to
     * @param printUniques Specifies if this object should append unique
     *      files
     * @param printCopies Specifies if this object should append files that
     *      have copies
     * @param printLength Specifies if this object should append the lengths
     *      of the files in a goup
    public PrintingDuplicatesStore(final Appendable out,
            final boolean printUniques, final boolean printCopies,
            final boolean printLength) {
        this.out = out;
        this.printingUniques = printUniques;
        this.printingCopies = printCopies;
        this.printingLength = printLength;
     * Add a file to the current group</p>
     * @param addMe The file to add
     * @return {@code true} always
     * @throws AppendException if an IOException occurs whilst attempting to
     *      append to the output.  The AppendException's cause is set to
     *      the IOException that was thrown.
    public boolean add(final File addMe) {
        try {
            if (currentBase == null) {
                currentBase = addMe;
                groupSize++;
            } else
            if (printingCopies) {
                out.append(addMe.toString());
                groupSize++;
            return true;
        } catch (final IOException ioe) {
            throw new AppendException(ioe);
     * Appends the file paths added since the last call to this method to
     * the output designated at construction</p>
     * @param keys Ignored
     * @return The number of files added between the last call and this call
     *      to this method
     * @throws AppendException if an IOException occurs whilst attempting to
     *      append to the output.  The AppendException's cause is set to
     *      the IOException that was thrown.
    public int group(final Object... keys) {
        try {
            if (groupSize == 1 && printingUniques)
                appendBase(currentBase);
        } catch (IOException ioe) {
            throw new AppendException(ioe);
        int rv = groupSize;
        groupSize = 0;
        return rv;
     * Called to append the base file to the output (follow the file name
     * with a path separator, a space, and the file's length, if neccessary)
     * </p>
     * @param base The file to add that is the base file for the group
     * @throws IOException If an IOException occurs whilst attempting to
     *      append to the output
    protected void appendBase(final File base) throws IOException {
        out.append(base.toString());
        if (printingLength)
            out.append(File.pathSeparator).append(" ")
                    .append(Long.toString(base.length()));
        out.append(LINE_SEPARATOR);
     * {@inheritDoc}
     * @param itr {@inheritDoc}
     * @return {@inheritDoc}
    public int addAll(final Iterable<File> itr) {
        return GroupingAddable.DefaultBehavior.addAll(this, itr);
* An object that prints duplicates, in order, as they are grouped</p>
* <p>
* The only difference between this and its superclass is that this removes
* and prints the first element in the group, then sorts the remaining
* elements before printing them.</p>
public class SortPrintingDuplicatesStore extends PrintingDuplicatesStore {
    /** Temporary storage for the current group */
    LinkedList<File> duplicates = new LinkedList<File>();
     * Creates a new instance whose behavior is specified by the given
     * parameters
     * @param out The output to append to
     * @param printUniques Specifies if this object should append unique
     *      files
     * @param printCopies Specifies if this object should append files that
     *      have copies
     * @param printLength Specifies if this object should append the lengths
     *      of the files in a goup
    public SortPrintingDuplicatesStore(final Appendable out,
            final boolean printUniques, final boolean printCopies,
            final boolean printLength) {
        super(out, printUniques, printCopies, printLength);
     * {@inheritDoc}
     * @param addMe {@inheritDoc}
     * @return {@inheritDoc}
    public boolean add(File addMe) {
        return duplicates.add(addMe);
     * {@inheritDoc}
     * @param keys {@inheritDoc}
     * @return {@inheritDoc}
    public int group(Object... keys) {
        try {
            groupSize = duplicates.size();
            if (groupSize > 1)
                if (printingCopies) {
                    appendBase(duplicates.pop());
                    sort(duplicates);
                    while (duplicates.size() > 0)
                        out.append("\t")
                                .append(duplicates.pop().toString())
                                .append(LINE_SEPARATOR);
                    return groupSize;
                } else
                    duplicates = new LinkedList<File>();
            else
            if (printingUniques)
                    appendBase(duplicates.pop());
            return groupSize;
        } catch (IOException ioe) {
            throw new AppendException(ioe);
}And the method that spawned all those interfaces and classes above
* Find identical files.</p>
* <p>
* Functions like {@code getDuplicates(bases, order, exceptions, subjects)},
* except that files in {@code subjects} that are found to be duplicates of
* files in {@code bases} are added to the given {@code store} instead of
* returned.</p>
* <p>
* If {@code bases} is not null, then the first file added to {@code store}
* after each call to {@link DuplicatesStore#group} is from {@code bases}.
* </p>
* @param <F> The desired type the returned collection should contain.  It
*      must be {@link File} or a subtype, and all elements in both
*      {@code bases} and {@code subjects} must be assignable to it.
* @param bases The only files to look for duplicates of
* @param order A comparator to apply to files
* @param exceptions The collection to add exceptions to, if they occur
* @param store The collection to store duplicate files in
* @param subjects The files to search for duplicates in.  Must implement
*      hasNext, next, hasPrevious, previous, and remove
* @see #getDuplicates(Collection, Comparator, Collection, ListIterator)
public static final <F extends File> void getDuplicates(
        final Collection<? extends F> bases, final Comparator<File> order,
        final Collection<? super IOException> exceptions,
        final GroupingAddable<? super F> store,
        final ListIterator<? extends F> subjects) {...}