比较两个链接列表

Question

What is the best way to compare two Linked lists in Java, I have two lists and want to make sure that none of the elements in one list are in the other. would something like this work both lists are Lists of LocalDates.

boolean doesNotContain (LinkedList L1, LinkedList L2) { 
        for(LocalDate d:L1) { 
            if(l2.contains(d){
                return false; 

            } 
        }
       return true;    
}    

Answer 1

Your solution works in N^2 complexity. If you sort both lists and iterate over them in one loop, you can do int in N log N (that is the sorting complexity).

You can also create two new Set s containing the elements from both lists, and then use containsAll() method - it will do all the work. It's a clean and easy to understand solution. Might be memory consuming though.

Comparison methods depend on methods equals() and hashCode() - if you do not properly override them in your LocalDate class, you will not get good results.

BTW1: break after return is a dead code

BTW2: naming methods with "not" seems like a bad idea. You will soon find yourself using !notFulfills( !notContains(sdflasdf)) . Goood luck trying to figure out what that does.

Answer 2

As your implementation of doesNotContain(..) is close to the implementation of the containsAll(..) implementation I would propose to use that one. If you execute list1.containsAll(list2) the implementation will loop over all elements of list2 to check if there is an equal object in list1 . That's the reason you need to override public boolean equals(Object obj) in LocalDate .

Find below a small example to show what's done by the containsAll(..)

the main procedure to run the check

public static void main(String[] args) throws Exception {
    List<LocalDate> list1 = new LinkedList<>();
    list1.add(new LocalDate("112233"));
    list1.add(new LocalDate("223344"));

    List<LocalDate> list2 = new LinkedList<>();
    list2.add(new LocalDate("112233"));
    list2.add(new LocalDate("112233"));

    System.out.println("list1 = " + list1);
    System.out.println("list2 = " + list2);

    System.out.println("list1.containsAll(list2) = " + list1.containsAll(list2));
    System.out.println("list2.containsAll(list1) = " + list2.containsAll(list1));
}

if you implement LocalDate without overriding the equals method, equals will be true only if you compare the references of the same object.

// a naive implementation for demonstration purpose
class LocalDate {

    String hour;
    String minute;
    String second;

    LocalDate(String string) {
        hour = string.substring(0, 2);
        minute = string.substring(2, 4);
        second = string.substring(4, 6);
    }

    @Override
    public String toString() {
        return String.format("LocalDate{%s%s%s} - hashcode: %d", hour, minute, second, this.hashCode());
    }
}

the result will be

list1 = [LocalDate{112233} - hashcode: 33039820, LocalDate{223344} - hashcode: 31311199]
list2 = [LocalDate{112233} - hashcode: 13177912, LocalDate{112233} - hashcode: 21924553]
list1.containsAll(list2) = false
list2.containsAll(list1) = false

if you override the equals method (hashcode has been omitted for demonstration purpose)

@Override
public boolean equals(Object obj) {
    if (obj == null) {
        return false;
    }
    if (getClass() != obj.getClass()) {
        return false;
    }
    final LocalDate other = (LocalDate) obj;
    System.out.println(toString() + ".equals(" + obj.toString() + ')');
    if (!Objects.equals(this.hour, other.hour)) {
        return false;
    }
    if (!Objects.equals(this.minute, other.minute)) {
        return false;
    }
    if (!Objects.equals(this.second, other.second)) {
        return false;
    }
    return true;
}

the output will be

list1 = [LocalDate{112233} - hashcode: 33336787, LocalDate{223344} - hashcode: 12767201]
list2 = [LocalDate{112233} - hashcode: 31311199, LocalDate{112233} - hashcode: 13177912]
// generated output by the method containsAll(..)
LocalDate{112233} - hashcode: 31311199.equals(LocalDate{112233} - hashcode: 33336787)
LocalDate{112233} - hashcode: 13177912.equals(LocalDate{112233} - hashcode: 33336787)
list1.containsAll(list2) = true
// generated output by the method containsAll(..)
LocalDate{112233} - hashcode: 33336787.equals(LocalDate{112233} - hashcode: 31311199)
LocalDate{223344} - hashcode: 12767201.equals(LocalDate{112233} - hashcode: 31311199)
LocalDate{223344} - hashcode: 12767201.equals(LocalDate{112233} - hashcode: 13177912)
list2.containsAll(list1) = false

based on the printed Object.hashcode() you can easily see that the containsAll() method loops over all elemnts in the list on which you call the method.

If you want to improve the check you need to clarify first following points - are the elements in the list unique -> then better use a Set - must the list have the same number of elements -> if yes you can compare as first step their sizes - if you need to check only that list2 has only elements which are in list1 (means the list contains unique values) -> call the containsAll method on list2 - it might also be worth to sort the lists before (depends on the contained data)

Without those information it is not possible to give a suggestion which will be the best in all cases.