Простий спосіб дізнатися, чи містять два різні списки абсолютно однакові елементи?

Який найпростіший спосіб знайти, якщо два Списки містять абсолютно однакові елементи в стандартних бібліотеках Java?

Не має значення, чи два списки однакові, чи ні, і не повинно мати значення, чи параметр типу списків відрізняється.

напр

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

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

Мабуть, щось дивиться мені в обличчя, яке я знаю :-)

EDIT: Щоб уточнити, я шукав ТОЧНІ ж елементи та кількість елементів, за порядком.

Якщо ви дбаєте про порядок, тоді просто використовуйте метод рівних:

list1.equals(list2)

Від javadoc:

Порівняє вказаний об'єкт із цим списком для рівності. Повертає істину, якщо і лише якщо вказаний об'єкт також є списком, обидва списки мають однаковий розмір, і всі відповідні пари елементів у двох списках рівні. (Два елементи e1 і e2 рівні, якщо (e1 == null? E2 == null: e1.equals (e2)). Іншими словами, два списки визначаються рівними, якщо вони містять однакові елементи в одному порядку . Це визначення гарантує, що метод рівних працює належним чином у різних реалізаціях інтерфейсу List.

Якщо ви хочете перевірити незалежно від порядку, ви можете скопіювати всі елементи до наборів та використати рівні на отриманих наборах:

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

Обмеженням цього підходу є те, що він не тільки ігнорує порядок, але й частоту повторюваних елементів. Наприклад, якщо list1було ["A", "B", "A"] і list2було ["A", "B", "B"], Setпідхід вважав би їх рівними.

Якщо вам потрібно бути нечутливим до порядку, але чутливим до частоти копій, ви можете:

• сортуйте обидва списки (або копії), перш ніж порівнювати їх, як це зроблено в цій відповіді на інше запитання
• або скопіюйте всі елементи на мультисети

Я розмістив купу речей у коментарях, я думаю, що це вимагає власної відповіді.

Як тут всі кажуть, використання рівняння () залежить від порядку. Якщо ви не дбаєте про замовлення, у вас є 3 варіанти.

Варіант 1

Використовуйте containsAll(). На мою думку, цей варіант не є ідеальним, оскільки він пропонує найгірші показники, O (n ^ 2).

Варіант 2

Для цього є дві варіанти:

2а) Якщо вам не байдуже підтримувати порядок своїх списків ... скористайтеся Collections.sort()обома списками. Потім використовуйте equals(). Це O (nlogn), тому що ви робите два сорти, а потім O (n) порівняння.

2b) Якщо вам потрібно підтримувати порядок списків, ви можете скопіювати обидва списки спочатку. ТАКОЖ ви можете використовувати рішення 2a в обох скопійованих списках. Однак це може бути непривабливим, якщо копіювання дуже дороге.

Це призводить до:

Варіант 3

Якщо ваші вимоги збігаються з частиною 2b , але копіювання занадто дороге. Ви можете використовувати TreeSet, щоб зробити сортування за вами. Скиньте кожен список у свій власний TreeSet. Він буде відсортований у наборі, а оригінальні списки залишаться недоторканими. Потім проведіть equals()порівняння на обох TreeSets. В TreeSetsи можуть бути вбудовані в O (NlogN) часу, і являє equals()собою О (п).

Обирайте :-).

EDIT: Я майже забув той самий застереження, на якийвказує Лоренс Гонсалвес . Реалізація TreeSet усуне дублікати. Якщо ви дбаєте про дублікати, вам знадобиться якийсь сортований мультисет.

Якщо ви використовуєте (або раді використовувати) колекції Apache Commons, ви можете використовувати CollectionUtils.isEqualCollection, яка "повертає справжнє, якщо дані колекції містять абсолютно однакові елементи з абсолютно однаковими кардиналіями".

Дуже пізно на вечірку, але хотів додати цю нульову безпечну перевірку:

Objects.equals(list1, list2)

Я знаю, що це стара тема, але жодна з інших відповідей повністю не вирішила мій варіант використання (я думаю, Guava Multiset може зробити те саме, але прикладу тут немає). Вибачте, будь ласка, про моє форматування. Я все ще нова в публікаціях на обміні стеками. Додатково повідомте мене, якщо є якісь помилки

Скажімо, у вас є List<T>a і List<T>b, і ви хочете перевірити, чи вони рівні з такими умовами:

1) O (n) очікуваний час виконання
2) Рівність визначається як: Для всіх елементів у a або b кількість разів, коли елемент виникає в a, дорівнює кількості разів, коли елемент виникає в b. Рівність елементів визначається як 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;
}

Час виконання - це O (n), оскільки ми робимо вставки O (2 * n) у хешмап і вибираємо хешмап O (3 * 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);

Спробуйте цю версію, яка не вимагає того, щоб замовлення було однаковим, але підтримує множини одного і того ж значення. Вони відповідають, лише якщо кожен має однакову кількість будь-якого значення.

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

Метод рівних у списку зробить це так, списки впорядковані, тому для рівності два списки повинні мати однакові елементи в одному порядку.

return list1.equals(list2);

Рішення для випадку, коли два списки мають однакові елементи, але різний порядок:

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

Відповідь Тома відмінна. Я повністю згоден з його відповідями!

Цікавим аспектом цього питання є те, чи потрібен вам сам Listтип та притаманне йому впорядкування.

Якщо ні, то ви не зможете перейти на деградацію, Iterableабо Collectionце дає певну гнучкість при проходженні структур даних, відсортованих за часом вставки, а не в той час, коли ви хочете перевірити.

Якщо замовлення ніколи не має значення (а у вас немає дублікатів елементів), спробуйте скористатись a Set.

Якщо порядок має значення, але визначено часом вставки (а у вас немає дублікатів), розгляньте, LinkedHashSetщо це як TreeSet, але впорядковано часом вставки (дублікати не враховуються). Це також дає вам O(1)доступний амортизований доступ O(log n).

Приклад коду:

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

На додаток до відповіді Лоранса, якщо ви також хочете зробити його безпечним:

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

Якщо ваш список містить користувацький клас MyClass, цей клас повинен перекривати equalsфункцію.

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

Примітка: якщо ви хочете перевірити рівність на java.util.Set, а не a java.util.List, ваш об'єкт повинен перекрити hashCode функцію.

Список.equals ()

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

Ви можете використовувати бібліотеку org.apache.commons.collections 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)

Перевірка обох списків не є нульовими. Якщо їх розміри різні, то ці списки не рівні. Створіть карти, що складаються з елементів списків як ключів та їх повторів як значень, та порівняйте карти.

Припущення, якщо обидва списки є нульовими, я вважаю їх рівними.

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

Зверніть увагу, для цих об'єктів повинні бути правильно визначені рівні методу. https://stackoverflow.com/a/24814634/4587961

Це залежить від того, який конкретний клас List ви використовуєте. Абстрактний клас AbstractCollection має метод, який називається міститьAll (Колекція), який приймає іншу колекцію (Список - це колекція) та:

Повертає істину, якщо ця колекція містить усі елементи зазначеної колекції.

Отже, якщо ArrayList передається у вас, ви можете зателефонувати за цим методом, щоб побачити, чи точно вони однакові.

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

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

    foo.containsAll(bar);

Причиною contentAll () є те, що воно повторюється через перший список, шукаючи відповідність у другому списку. Тож якщо вони вийшли з ладу, дорівнює (), це не підбере.

EDIT: Я просто хочу зауважити тут про амортизований час виконання різних пропонованих варіантів. Чи важливий час роботи? Звичайно. Це єдине, що вам слід врахувати? Немає.

Вартість копіювання КОГО-небудь одного елемента зі своїх списків до інших списків вимагає часу, а також займає хороший фрагмент пам’яті (що фактично збільшує подвоєння пам'яті, яку ви використовуєте).

Отже, якщо пам'ять у вашому JVM не викликає проблем (що це, як правило, має бути), то вам все одно потрібно врахувати час, необхідний для копіювання кожного елемента з двох списків у два TreeSets. Пам'ятайте, вона сортує кожен елемент під час їх введення.

Моя остання порада? Потрібно врахувати свій набір даних та кількість елементів у вашому наборі даних, а також наскільки великий кожен об’єкт у вашому наборі даних, перш ніж ви зможете прийняти тут хороше рішення. Пограйте з ними, створіть один із них і подивіться, який з них працює швидше. Це гарна вправа.