Cách đơn giản để tìm nếu hai danh sách khác nhau chứa chính xác các yếu tố?

Cách đơn giản nhất để tìm nếu hai Danh sách chứa chính xác các phần tử giống nhau, trong các thư viện Java tiêu chuẩn là gì?

Sẽ không có vấn đề gì nếu hai Danh sách có cùng thể hiện hay không và không thành vấn đề nếu tham số loại của Danh sách khác nhau.

ví dụ

List list1
List<String> list2; 
// ... construct etc

list1.add("A");
list2.add("A"); 
// the function, given these two lists, should return true

Có lẽ có điều gì đó nhìn chằm chằm vào mặt tôi biết :-)

EDIT: Để làm rõ, tôi đã tìm kiếm các yếu tố CHÍNH XÁC và số lượng các yếu tố theo thứ tự.

Nếu bạn quan tâm đến thứ tự, thì chỉ cần sử dụng phương thức bằng:

list1.equals(list2)

Từ javadoc:

So sánh các đối tượng được chỉ định với danh sách này cho bình đẳng. Trả về true nếu và chỉ khi đối tượng được chỉ định cũng là một danh sách, cả hai danh sách có cùng kích thước và tất cả các cặp phần tử tương ứng trong hai danh sách đều bằng nhau. (Hai phần tử e1 và e2 bằng nhau nếu (e1 == null? E2 == null: e1.equals (e2)).) Nói cách khác, hai danh sách được xác định là bằng nhau nếu chúng có cùng các phần tử theo cùng một thứ tự . Định nghĩa này đảm bảo rằng phương thức bằng hoạt động đúng trong các triển khai khác nhau của giao diện Danh sách.

Nếu bạn muốn kiểm tra độc lập với thứ tự, bạn có thể sao chép tất cả các thành phần vào Bộ và sử dụng bằng trên Bộ kết quả:

public static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
    return new HashSet<>(list1).equals(new HashSet<>(list2));
}

Một hạn chế của phương pháp này là nó không chỉ bỏ qua trật tự, mà còn tần suất của các yếu tố trùng lặp. Ví dụ, nếulist1 là ["A", "B", "A"] và list2là ["A", "B", "B"] thì Setcách tiếp cận sẽ coi chúng là bằng nhau.

Nếu bạn cần không nhạy cảm với thứ tự nhưng nhạy cảm với tần suất trùng lặp, bạn có thể:

• sắp xếp cả hai danh sách (hoặc bản sao) trước khi so sánh chúng, như được thực hiện trong câu trả lời này cho câu hỏi khác
• hoặc sao chép tất cả các yếu tố vào Multiset

Tôi đã đăng một loạt các công cụ trong các bình luận Tôi nghĩ rằng nó đảm bảo câu trả lời của riêng mình.

Như mọi người nói ở đây, sử dụng bằng () phụ thuộc vào thứ tự. Nếu bạn không quan tâm đến thứ tự, bạn có 3 lựa chọn.

lựa chọn 1

Sử dụng containsAll(). Theo tôi, tùy chọn này không lý tưởng, vì nó cung cấp hiệu suất trường hợp xấu nhất, O (n ^ 2).

Lựa chọn 2

Có hai biến thể cho điều này:

2a) Nếu bạn không quan tâm đến việc duy trì thứ tự danh sách của bạn ... hãy sử dụng Collections.sort()trên cả hai danh sách. Sau đó sử dụng equals(). Đây là O (nlogn), vì bạn thực hiện hai loại và sau đó là so sánh O (n).

2b) Nếu bạn cần duy trì thứ tự của danh sách, bạn có thể sao chép cả hai danh sách trước. THEN bạn có thể sử dụng giải pháp 2a trên cả hai danh sách được sao chép. Tuy nhiên điều này có thể không hấp dẫn nếu sao chép rất tốn kém.

Điều này dẫn đến:

Lựa chọn 3

Nếu yêu cầu của bạn giống như phần 2b , nhưng sao chép quá đắt. Bạn có thể sử dụng một TreeSet để sắp xếp cho bạn. Kết xuất mỗi danh sách vào TreeSet của chính nó. Nó sẽ được sắp xếp trong tập hợp, và các danh sách ban đầu sẽ vẫn còn nguyên. Sau đó thực hiện equals()so sánh trên cả hai TreeSets. Các TreeSetss có thể được xây dựng trong thời gian O (nlogn) vàequals() O (n).

Bạn chọn đi :-).

EDIT: Tôi gần như quên mất lời cảnh báo tương tự mà Laurence Gonsalves chỉ ra. Việc thực hiện TreeSet sẽ loại bỏ các bản sao. Nếu bạn quan tâm đến các bản sao, bạn sẽ cần một số loại sắp xếp nhiều trang.

Nếu bạn đang sử dụng (hoặc rất vui khi sử dụng) Bộ sưu tập Apache Commons, bạn có thể sử dụng CollectionUtils.isEqualCollection , "trả về đúng nếu các Bộ sưu tập đã cho chứa chính xác các yếu tố có cùng chính xác."

Rất muộn cho bữa tiệc nhưng muốn thêm kiểm tra an toàn null này:

Objects.equals(list1, list2)

Tôi biết đây là một chủ đề cũ, nhưng không có câu trả lời nào khác giải quyết hoàn toàn trường hợp sử dụng của tôi (tôi đoán Guava Multiset có thể làm tương tự, nhưng không có ví dụ nào ở đây). Xin thứ lỗi cho định dạng của tôi. Tôi vẫn còn mới để đăng trên stack trao đổi. Ngoài ra, hãy cho tôi biết nếu có bất kỳ lỗi nào

Hãy nói rằng bạn có List<T>a và List<T>b và bạn muốn kiểm tra xem chúng có bằng các điều kiện sau không:

1) O (n) thời gian chạy dự kiến
2) Bình đẳng được định nghĩa là: Với tất cả các phần tử trong a hoặc b, số lần phần tử xảy ra trong a bằng số lần phần tử xảy ra trong b. Bình đẳng phần tử được định nghĩa là T.equals ()

private boolean listsAreEquivelent(List<? extends Object> a, List<? extends Object> b) {
    if(a==null) {
        if(b==null) {
            //Here 2 null lists are equivelent. You may want to change this.
            return true;
        } else {
            return false;
        }
    }
    if(b==null) {
        return false;
    }
    Map<Object, Integer> tempMap = new HashMap<>();
    for(Object element : a) {
        Integer currentCount = tempMap.get(element);
        if(currentCount == null) {
            tempMap.put(element, 1);
        } else {
            tempMap.put(element, currentCount+1);
        }
    }
    for(Object element : b) {
        Integer currentCount = tempMap.get(element);
        if(currentCount == null) {
            return false;
        } else {
            tempMap.put(element, currentCount-1);
        }
    }
    for(Integer count : tempMap.values()) {
        if(count != 0) {
            return false;
        }
    }
    return true;
}

Thời gian chạy là O (n) vì chúng tôi đang thực hiện chèn O (2 * n) vào một hashmap và hashmap O (3 * n) chọn. Tôi chưa kiểm tra đầy đủ mã này, vì vậy hãy cẩn thận :)

//Returns true:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","A"));
listsAreEquivelent(null,null);
//Returns false:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),null);

Hãy thử phiên bản này không yêu cầu thứ tự giống nhau nhưng không hỗ trợ có nhiều giá trị giống nhau. Chúng chỉ khớp nhau nếu mỗi cái có cùng số lượng của bất kỳ giá trị nào.

public boolean arraysMatch(List<String> elements1, List<String> elements2) {
    // Optional quick test since size must match
    if (elements1.size() != elements2.size()) {
        return false;
    }
    List<String> work = newArrayList(elements2);
    for (String element : elements1) {
        if (!work.remove(element)) {
            return false;
        }
    }
    return work.isEmpty();
}

Phương thức bằng trong Danh sách sẽ thực hiện việc này, Danh sách được sắp xếp theo thứ tự, do đó, để bằng hai Danh sách phải có cùng các phần tử theo cùng một thứ tự.

return list1.equals(list2);

Giải pháp cho trường hợp khi hai danh sách có cùng các yếu tố, nhưng thứ tự khác nhau:

public boolean isDifferentLists(List<Integer> listOne, List<Integer> listTwo) {
    if(isNullLists(listOne, listTwo)) {
        return false;
    }

    if (hasDifferentSize(listOne, listTwo)) {
        return true;
    }

    List<Integer> listOneCopy = Lists.newArrayList(listOne);
    List<Integer> listTwoCopy = Lists.newArrayList(listTwo);
    listOneCopy.removeAll(listTwoCopy);

    return CollectionUtils.isNotEmpty(listOneCopy);
}

private boolean isNullLists(List<Integer> listOne, List<Integer> listTwo) {
    return listOne == null && listTwo == null;
}

private boolean hasDifferentSize(List<Integer> listOne, List<Integer> listTwo) {
    return (listOne == null && listTwo != null) || (listOne != null && listTwo == null) || (listOne.size() != listTwo.size());
}

Câu trả lời của Tom là tuyệt vời Tôi hoàn toàn đồng ý với câu trả lời của anh ấy!

Một khía cạnh thú vị của câu hỏi này là, liệu bạn có cần Listloại chính nó và thứ tự vốn có của nó hay không.

Nếu không, bạn có thể giảm xuống Iterablehoặc Collectioncho phép bạn linh hoạt chuyển qua các cấu trúc dữ liệu được sắp xếp theo thời gian chèn, thay vì tại thời điểm bạn muốn kiểm tra.

Nếu thứ tự không bao giờ có vấn đề (và bạn không có các yếu tố trùng lặp) hãy xem xét sử dụng a Set.

Nếu thứ tự quan trọng nhưng được xác định bởi thời gian chèn (và bạn không có trùng lặp), hãy xem xét một LinkedHashSetthứ giống như TreeSet nhưng được sắp xếp theo thời gian chèn (không được tính trùng lặp). Điều này cũng cung cấp cho bạn O(1)truy cập khấu hao ngay lập tức O(log n).

Mã mẫu:

public static '<'T'>' boolean isListDifferent(List'<'T'>' previousList,
        List'<'T'>' newList) {

    int sizePrevoisList = -1;
    int sizeNewList = -1;

    if (previousList != null && !previousList.isEmpty()) {
        sizePrevoisList = previousList.size();
    }
    if (newList != null && !newList.isEmpty()) {
        sizeNewList = newList.size();
    }

    if ((sizePrevoisList == -1) && (sizeNewList == -1)) {
        return false;
    }

    if (sizeNewList != sizePrevoisList) {
        return true;
    }

    List n_prevois = new ArrayList(previousList);
    List n_new = new ArrayList(newList);

    try {
        Collections.sort(n_prevois);
        Collections.sort(n_new);
    } catch (ClassCastException exp) {
        return true;
    }

    for (int i = 0; i < sizeNewList; i++) {
        Object obj_prevois = n_prevois.get(i);
        Object obj_new = n_new.get(i);
        if (obj_new.equals(obj_prevois)) {
            // Object are same
        } else {
            return true;
        }
    }

    return false;
}

Ngoài câu trả lời của Laurence, nếu bạn cũng muốn làm cho nó an toàn:

private static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
    if (list1 == null)
        return list2==null;
    if (list2 == null)
        return list1 == null;
    return new HashSet<>(list1).equals(new HashSet<>(list2));
}

list1.equals(list2);

Nếu danh sách của bạn chứa Class MyClass tùy chỉnh, lớp này phải ghi đè equalshàm.

 class MyClass
  {
  int field=0;
  @0verride
  public boolean equals(Object other)
        {
        if(this==other) return true;
        if(other==null || !(other instanceof MyClass)) return false;
        return this.field== MyClass.class.cast(other).field;
        }
  }

Lưu ý: nếu bạn muốn kiểm tra bằng với java.util.Set chứ không phải a java.util.List, thì đối tượng của bạn phải ghi đè hashCode hàm.

List.equals ()

http://java.sun.com/j2se/1.5/docs/api/java/util/List.html#equals(java.lang.Object)

Bạn có thể sử dụng thư viện org.apache.commons.collections của Apache: http://commons.apache.org/collections/apidocs/org/apache/commons/collections/ListUtils.html

public static boolean isEqualList(java.util.Collection list1,
                              java.util.Collection list2)

Kiểm tra cả hai danh sách không phải là null. Nếu kích thước của chúng là khác nhau, thì những danh sách này không bằng nhau. Xây dựng bản đồ bao gồm các yếu tố của danh sách làm khóa và lặp lại chúng làm giá trị và so sánh các bản đồ.

Giả định, nếu cả hai danh sách đều là null, tôi coi chúng là bằng nhau.

private boolean compareLists(List<?> l1, List<?> l2) {
    if (l1 == null && l2 == null) {
        return true;
    } else if (l1 == null || l2 == null) {
        return false;
    }

    if (l1.size() != l2.size()) {
        return false;
    }

    Map<?, Integer> m1 = toMap(l1);
    Map<?, Integer> m2 = toMap(l2);

    return m1.equals(m2);
}

private Map<Object, Integer> toMap(List<?> list) {
    //Effective size, not to resize in the future.
    int mapSize = (int) (list.size() / 0.75 + 1);
    Map<Object, Integer> map = new HashMap<>(mapSize);

    for (Object o : list) {
        Integer count = map.get(o);
        if (count == null) {
            map.put(o, 1);
        } else {
            map.put(o, ++count);
        }
    }

    System.out.println(map);
    return map;
}

Xin lưu ý, phương thức bằng phải được xác định đúng cho các đối tượng này. https://stackoverflow.com/a/24814634/4587961

Nó phụ thuộc vào lớp List cụ thể mà bạn đang sử dụng. Lớp trừu tượng AbstractCollection có một phương thức gọi là chứa All (Bộ sưu tập) lấy một bộ sưu tập khác (Danh sách là một bộ sưu tập) và:

Trả về true nếu bộ sưu tập này chứa tất cả các thành phần trong bộ sưu tập đã chỉ định.

Vì vậy, nếu một ArrayList đang được truyền vào, bạn có thể gọi phương thức này để xem chúng có giống hệt nhau không.

       List foo = new ArrayList();
    List bar = new ArrayList();
    String str = "foobar";

    foo.add(str);
    bar.add(str);

    foo.containsAll(bar);

Lý do cho chứa All () là vì nó lặp qua danh sách đầu tiên tìm kiếm sự trùng khớp trong danh sách thứ hai. Vì vậy, nếu họ không theo thứ tự bằng () sẽ không nhận nó.

EDIT: Tôi chỉ muốn đưa ra nhận xét ở đây về thời gian hoạt động được khấu hao để thực hiện các tùy chọn khác nhau được cung cấp. Thời gian chạy có quan trọng không? Chắc chắn rồi. Đó có phải là điều duy nhất bạn nên xem xét? Không.

Chi phí sao chép MỌI yếu tố duy nhất từ ​​danh sách của bạn vào các danh sách khác đều mất thời gian và nó cũng chiếm một phần bộ nhớ tốt (nhân đôi hiệu quả bộ nhớ bạn đang sử dụng).

Vì vậy, nếu bộ nhớ trong JVM của bạn không phải là vấn đề đáng lo ngại (thường là vậy) thì bạn vẫn cần xem xét thời gian cần thiết để sao chép mọi phần tử từ hai danh sách vào hai TreeSets. Hãy nhớ rằng nó đang sắp xếp mọi yếu tố khi nó đi vào chúng.

Lời khuyên cuối cùng của tôi? Bạn cần xem xét tập dữ liệu của mình và số lượng phần tử bạn có trong tập dữ liệu của mình và mức độ lớn của từng đối tượng trong tập dữ liệu của bạn trước khi bạn có thể đưa ra quyết định tốt ở đây. Chơi xung quanh với chúng, tạo từng cái một và xem cái nào chạy nhanh hơn. Đó là một bài tập tốt.