Delete duplicates from unsorted linked list

I also am not a fan of the code organization. I think a better way to approach this would be to implement the List interface around an ordered set like a LinkedHashSet as something like a SetList. Many of the methods could simply be delegated to the internal set, and only a few would really be left to implement.

Your code has a separate method, eliminateDuplicates, to filter out the duplicates, rather than filtering them as they are added. This means that, if that method is not called, the list is not consistent with its requirements. I would still get all the duplicates. A better strategy is to remove the duplicates as they are added to keep the list always consistent with its advertised behavior.

Lastly, the names of your test methods could use a little work. Names like test1 and test2 don't tell much of what the tests are or what they are testing.

Your implementations of equals and hashCode violate the contract of hashCode:

If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.

The following code prints true false:

EliminateDuplicateUnsortedLL<Integer> a = new EliminateDuplicateUnsortedLL<>(Arrays.asList(1));
EliminateDuplicateUnsortedLL<Integer> b = new EliminateDuplicateUnsortedLL<>(Arrays.asList(1));
System.out.printf("%b %b%n", a.equals(b), a.hashCode() == b.hashCode());

I don't like how you organised your code. I would think you just need an utility method

List <T> removeDuplicates (List <T> source)

Or a class:

ListWithoutDuplicates extends List <T>

In the first case you would need to produce a new list filtering the source one. In the second you would need to wrap an existing list providing a view that does not show its duplicate elements.

What I don't like in this approach is that the name suggests that we have a linked list but it does not follow the APIs in the list interface.

Another thing that looks quite bad to me is that you need to explicitly call the method to remove duplicates

Unit testing

Your unit tests are not easy to read. You could improve that by extracting the common logic of what they do to a helper method that you can reuse by all of those tests, for example:

private void assertEqualsAfterDeleteDups(List<Integer> expected, List<Integer> orig) {
    LinkedList<Integer> linkedList = new LinkedList<>(orig);
    linkedList.eliminateDuplicates();
    assertEquals(new LinkedList<>(expected), linkedList);
}

This way, instead of:

@Test
public void test2() {
    LinkedListWithEliminateDups<Integer> edu2 = new LinkedListWithEliminateDups<Integer>(Arrays.asList(7, 2, 5, 10, 4, 2, 9, 10));
    edu2.eliminateDuplicates();

    LinkedListWithEliminateDups<Integer> eduExpected2 = new LinkedListWithEliminateDups<Integer>(Arrays.asList(7, 2, 5, 10, 4, 9));
    assertEquals(eduExpected2, edu2);
}

You could write in a more compact way:

@Test
public void test2() {
    assertEqualsAfterDeleteDups(Arrays.asList(7, 2, 5, 10, 4, 9), Arrays.asList(7, 2, 5, 10, 4, 2, 9, 10));
}

And you could apply this to all your test methods.

I also strongly recommend to do not only assertEquals, but throw in at least a few assertNotEquals as well. It's important to test your implementation from multiple angles, otherwise there could be bugs that remain hidden from one-sided tests.

So I would add another helper for the not-equals tests:

private void assertNotEqualsAfterDeleteDups(List<Integer> expected, List<Integer> orig) {
    LinkedList<Integer> linkedList = new LinkedList<>(orig);
    linkedList.eliminateDuplicates();
    assertNotEquals(new LinkedList<>(expected), linkedList);
}

And I would add some more tests for potential corner cases:

@Test
public void testEliminateSingleDup() {
    assertEqualsAfterDeleteDups(Arrays.asList(1, 2, 3, 4, 5, 7), Arrays.asList(1, 2, 3, 4, 5, 4, 3, 7));
    assertNotEqualsAfterDeleteDups(Arrays.asList(1, 3, 4, 5, 7), Arrays.asList(1, 2, 3, 4, 5, 4, 3, 7));
    assertNotEqualsAfterDeleteDups(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6));
}

@Test
public void testEliminateSingleDupAtStart() {
    assertEqualsAfterDeleteDups(Arrays.asList(1, 2, 3), Arrays.asList(1, 1, 2, 3));
}

@Test
public void testEliminateSingleDupAtEnd() {
    assertEqualsAfterDeleteDups(Arrays.asList(1, 2, 3), Arrays.asList(1, 2, 3, 3));
}

@Test
public void testEliminateManyDups() {
    assertEqualsAfterDeleteDups(Arrays.asList(1, 2, 3), Arrays.asList(1, 1, 2, 2, 2, 3, 3, 3));
}

@Test
public void testEliminateNothing() {
    assertEqualsAfterDeleteDups(Arrays.asList(1, 2, 3), Arrays.asList(1, 2, 3));
    assertNotEqualsAfterDeleteDups(Arrays.asList(1, 2), Arrays.asList(1, 2, 3));
}

@Test
public void testEmpty() {
    assertEqualsAfterDeleteDups(Arrays.asList(), Arrays.asList());
    assertNotEqualsAfterDeleteDups(Arrays.asList(2), Arrays.asList());
}

@Test
public void testSingletonList() {
    assertEqualsAfterDeleteDups(Arrays.asList(2), Arrays.asList(2));
    assertNotEqualsAfterDeleteDups(Arrays.asList(3), Arrays.asList(2));
}

Reuse your previous LinkedList classes

The linked list implementation is almost the same as in your previous question. I strongly recommend to start using inheritance, and instead of copy-pasting the previous implementation and adding a single new eliminateDuplicates method, extend the previous implementation.

Your new class for this problem could be:

class LinkedListWithEliminateDups<T> extends LinkedList<T> {

    public LinkedListWithEliminateDups(List<T> items) {
        super(items);
    }

    public void eliminateDuplicates() {
        final Set<T> set = new HashSet<T>();
        Node<T> prev = null;
        for (Node<T> node = first; node != null; node = node.next) {
            if (set.contains(node.item)) {
                prev.next = node.next;
            } else {
                set.add(node.item);
                prev = node;
            }
        }
        last = prev;
    }
}

And the old class that you can use as the base:

class LinkedList<T> {

    Node<T> first;
    Node<T> last;

    public LinkedList(List<T> items) {
        for (T item : items) {
            create(item);
        }
    }

    private void create(T item) {
        Node<T> node = new Node<>(item);
        if (first == null) {
            first = last = node;
        } else {
            last.next = node;
            last = node;
        }
    }

    @Override
    public int hashCode() {
        int hashCode = 1;
        for (Node<T> node = first; node != null; node = node.next) {
            hashCode = 31 * hashCode + node.hashCode();
        }
        return hashCode;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof LinkedList) {
            LinkedList<T> other = (LinkedList<T>) obj;
            Node<T> currentListNode = first;
            Node<T> otherListNode = other.first;

            while (currentListNode != null && otherListNode != null) {
                if (!currentListNode.item.equals(otherListNode.item)) {
                    return false;
                }
                currentListNode = currentListNode.next;
                otherListNode = otherListNode.next;
            }
            return currentListNode == null && otherListNode == null;
        }
        return false;
    }

    static class Node<T> {
        Node<T> next;
        T item;

        Node(T item) {
            this.item = item;
        }
    }
}