İki farklı listenin tam olarak aynı öğeleri içerip içermediğini bulmanın kolay yolu?

İki Liste'nin standart Java kitaplıklarında tam olarak aynı öğeleri içerip içermediğini bulmanın en kolay yolu nedir?

İki Listenin aynı örnek olup olmadığı veya Listelerin type parametresinin farklı olup olmadığı önemli olmamalıdır.

Örneğin

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

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

Muhtemelen yüzüme bakan bir şey var biliyorum biliyorum :-)

DÜZENLEME: Açıklığa kavuşturmak için, sırayla EXACT aynı öğeleri ve öğe sayısını arıyordum.

Siparişi önemsiyorsanız, eşittir yöntemini kullanın:

list1.equals(list2)

Javadoc'tan:

Eşitlik için belirtilen nesneyi bu listeyle karşılaştırır. Yalnızca belirtilen nesne de bir listeyse, her iki liste de aynı boyuta sahipse ve iki listedeki karşılık gelen tüm öğe çiftleri eşitse true değerini döndürür. (E1 ve e2 öğelerinin iki öğesi eşitse (e1 == null? E2 == null: e1.equals (e2)). Başka bir deyişle, aynı öğeleri aynı sırayla içeriyorlarsa iki liste eşit olarak tanımlanır . Bu tanım, eşitleme yönteminin Liste arabiriminin farklı uygulamalarında düzgün çalışmasını sağlar.

Siparişten bağımsız olarak kontrol etmek isterseniz, tüm öğeleri Setlere kopyalayabilir ve elde edilen Setlerde eşittir kullanabilirsiniz:

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

Bu yaklaşımın bir sınırlaması, sadece düzeni değil, aynı zamanda yinelenen öğelerin sıklığını da göz ardı etmesidir. Örneğin list1, ["A", "B", "A"] ve list2["A", "B", "B"] Setolsaydı , yaklaşım bunların eşit olduğunu düşünürdü.

Siparişe duyarsız olmanız, ancak kopyaların sıklığına duyarlı olmanız gerekirse:

• her iki listeyi (veya kopyaları) karşılaştırmadan önce, bu cevapta başka bir soruya yapıldığı gibi sıralayın
• veya tüm öğeleri bir Multiset'e kopyalayın

Kendi cevabını gerektirdiğini düşünüyorum yorumlarda bir sürü şey yayınladım.

Herkesin dediği gibi, equals () kullanımı sıraya bağlıdır. Siparişle ilgilenmiyorsanız 3 seçeneğiniz var.

seçenek 1

Kullanın containsAll(). Bence bu seçenek ideal değil çünkü en kötü durum performansı sunuyor O (n ^ 2).

seçenek 2

Bunun iki varyasyonu vardır:

2a) Listelerinizin sırasını korumakla ilgilenmiyorsanız ... Collections.sort()her iki listede de kullanın . Ardından equals(). Bu O (nlogn), çünkü iki tür ve sonra bir O (n) karşılaştırması yaparsınız.

2b) Listelerin sırasını korumanız gerekiyorsa, önce her iki listeyi de kopyalayabilirsiniz. Ardından , kopyalanan her iki listede de çözüm 2a'yı kullanabilirsiniz . Ancak, kopyalama çok pahalıysa bu çekici olmayabilir.

Bu şunlara yol açar:

Seçenek 3

Gereksinimleriniz bölüm 2b ile aynıysa , ancak kopyalama çok pahalıdır. Sıralamayı sizin için yapmak için bir TreeSet kullanabilirsiniz. Her listeyi kendi TreeSet içine dökün. Kümede sıralanacak ve orijinal listeler bozulmadan kalacaktır. Ardından equals()her iki TreeSets için de bir karşılaştırma yapın . TreeSetsS O (nlogn) zaman inşa edilebilir ve equals()O (n) 'dir.

İstediğini al :-).

EDIT: Laurence Gonsalves'in belirttiği uyarıyı neredeyse unutuyordum. TreeSet uygulaması yinelemeleri ortadan kaldıracaktır. Yinelemeleri önemsiyorsanız, bir çeşit sıralı çoklu kümeye ihtiyacınız olacaktır.

Kullanmakta (veya kullanmak için mutluyuz) Apache Commons Koleksiyonları ediyorsanız kullanabilirsiniz CollectionUtils.isEqualCollection hangi "Verilen Koleksiyonları IFF gerçek döner tam olarak aynı kardinallikleri ile tam olarak aynı öğeler içerir."

Partiye çok geç ama bu boş güvenli çeki eklemek istedim:

Objects.equals(list1, list2)

Bu eski bir iş parçacığı olduğunu biliyorum, ama diğer cevapların hiçbiri benim kullanım davasını tamamen çözdü (Guava Multiset aynı şeyi yapabilir, ama burada bir örnek yok). Lütfen biçimlendirmemi affedin. Hala yığın borsasında yayınlama konusunda yeniyim. Ayrıca herhangi bir hata olup olmadığını bana bildirin

Diyelim ki List<T>a ve List<T>b'ye sahip olduğunuzu ve bunların aşağıdaki koşullara eşit olup olmadığını kontrol etmek istediğinizi varsayalım:

1) O (n) beklenen çalışma süresi
2) Eşitlik şu şekilde tanımlanır: a veya b'deki tüm öğeler için, öğenin a'da meydana gelme sayısı, öğenin b'de gerçekleşme sayısına eşittir. Eleman eşitliği T.equals () olarak tanımlanır

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;
}

Çalışma süresi O (n) 'dir çünkü bir hashmap içine O (2 * n) yerleştirmeler yapıyoruz ve O (3 * n) hashmap seçimleri yapıyoruz. Bu kodu tamamen test etmedim, bu yüzden dikkatli olun :)

//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);

Siparişin aynı olmasını gerektirmeyen, ancak aynı değerin birden fazlasına sahip olmayı destekleyen bu sürümü deneyin. Yalnızca her biri herhangi bir değerde aynı miktarda olduğunda eşleşirler.

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();
}

Liste'deki eşittir yöntemi bunu yapar, Listeler sıralanır, böylece iki tane olmak için Listelerin aynı sırada aynı öğeleri olması gerekir.

return list1.equals(list2);

İki listenin aynı öğelere, ancak farklı sıraya sahip olduğu durumlar için çözüm:

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());
}

Tom'un cevabı mükemmel, cevaplarına tamamen katılıyorum!

Bu sorunun ilginç bir yönü, Listtürün kendisine ve onun doğal düzenine ihtiyacınız olup olmadığıdır .

Değilse, Iterable veya Collectionsize yerine kontrol etmek istediğiniz zaman ekleme zamanında sıralanır veri yapılarını etrafında geçen bazı esneklik tanıyor.

Sipariş hiç önemli değilse (ve yinelenen öğeleriniz yoksa) Set .

Sipariş LinkedHashSetönemliyse, ekleme zamanı ile tanımlanmışsa (ve yinelemeleriniz yoksa) TreeSet'e benzeyen ancak ekleme süresine göre sıralananı (yinelemeler sayılmaz) düşünün . Bu aynı zamanda size O(1)amortismana tabi erişim sağlar O(log n).

Basit kod:

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;
}

Laurence'ın cevabına ek olarak, bunu da null-güvenli yapmak istiyorsanız:

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);

Listeniz özel bir Sınıf Sınıfım içeriyorsa, bu sınıfın equalsişlevi geçersiz kılması gerekir .

 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;
        }
  }

Not: a yerine bir java.util.Set üzerinde eşitlikleri test etmek istiyorsanız java.util.List, nesnenizin hashCode işlevi geçersiz kılması gerekir .

List.equals ()

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

Apache'nin org.apache.commons.collections kütüphanesini kullanabilirsiniz: http://commons.apache.org/collections/apidocs/org/apache/commons/collections/ListUtils.html

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

Her iki listenin de boş olup olmadığını kontrol edin. Boyutları farklıysa, bu listeler eşit değildir. Listelerin anahtar olarak elemanlarından ve tekrar olarak değerlerden oluşan haritalar oluşturun ve haritaları karşılaştırın.

Varsayımlar, eğer her iki liste de boşsa, ben onları eşit sayıyorum.

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;
}

Bu nesneler için yöntem eşitlerinin düzgün bir şekilde tanımlanması gerektiğini lütfen unutmayın. https://stackoverflow.com/a/24814634/4587961

Hangi somut Liste sınıfını kullandığınıza bağlıdır. AbstractCollection soyut sınıfı, başka bir koleksiyon alan (List bir koleksiyon) ve includeAll (Koleksiyon) adında bir yönteme sahiptir ve:

Bu koleksiyon belirtilen koleksiyondaki tüm öğeleri içeriyorsa true değerini döndürür.

Dolayısıyla, bir ArrayList iletiliyorsa, tam olarak aynı olup olmadıklarını görmek için bu yöntemi çağırabilirsiniz.

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

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

    foo.containsAll(bar);

İncludeAll () öğesinin nedeni, ikinci listede eşleşmeyi arayan ilk listede yinelenmesidir. Yani eğer bozuklarsa eşittir () onu almayacaktır.

EDIT: Ben sadece burada sunulan çeşitli seçenekleri gerçekleştirme amortisman çalışma süresi hakkında yorum yapmak istiyorum. Çalışma süresi önemli mi? Elbette. Düşünmeniz gereken tek şey bu mu? Hayır.

HER tek öğeyi listelerinizden diğer listelere kopyalamanın maliyeti zaman alır ve ayrıca iyi bir bellek alanı kullanır (kullandığınız belleği etkili bir şekilde iki katına çıkarır).

Bu nedenle, JVM'nizdeki bellek bir endişe değilse (genellikle olması gerekir), o zaman yine de her öğeyi iki listeden iki TreeSet'e kopyalamak için gereken süreyi göz önünde bulundurmanız gerekir. Her öğeyi girerken sıraladığını unutmayın.

Son tavsiyem? Burada iyi bir karar verebilmeniz için veri kümenizi ve veri kümenizde kaç öğe olduğunu ve veri kümenizdeki her nesnenin ne kadar büyük olduğunu göz önünde bulundurmanız gerekir. Onlarla oynayın, her şekilde bir tane oluşturun ve hangisinin daha hızlı çalıştığını görün. İyi bir egzersiz.