Як я можу розрахувати різницю між двома списками масивів?

У мене є два ArrayLists.

ArrayList A містить:

['2009-05-18','2009-05-19','2009-05-21']

ArrayList B містить:

['2009-05-18','2009-05-18','2009-05-19','2009-05-19','2009-05-20','2009-05-21','2009-05-21','2009-05-22']

Мені потрібно порівняти ArrayList A та ArrayList B. Результат ArrayList повинен містити Список, якого не існує в ArrayList A.

Результатом ArrayList має бути:

['2009-05-20','2009-05-22']

як порівняти?

У Java ви можете використовувати метод Collectionінтерфейсу removeAll.

// Create a couple ArrayList objects and populate them
// with some delicious fruits.
Collection firstList = new ArrayList() {{
    add("apple");
    add("orange");
}};

Collection secondList = new ArrayList() {{
    add("apple");
    add("orange");
    add("banana");
    add("strawberry");
}};

// Show the "before" lists
System.out.println("First List: " + firstList);
System.out.println("Second List: " + secondList);

// Remove all elements in firstList from secondList
secondList.removeAll(firstList);

// Show the "after" list
System.out.println("Result: " + secondList);

Наведений вище код дасть такий результат:

First List: [apple, orange]
Second List: [apple, orange, banana, strawberry]
Result: [banana, strawberry]

Ви вже маєте правильну відповідь. А якщо ви хочете зробити більш складні та цікаві операції між Списками (колекціями), використовуйте колекції apache commons ( CollectionUtils ). Це дозволяє робити кон’юкцію / диз’юнкцію, знаходити перетин, перевіряти, чи одна колекція є підмножиною іншої та інші приємні речі.

У Java 8 з потоками це насправді досить просто. EDIT: Може бути ефективним без потоків, див. Нижче.

List<String> listA = Arrays.asList("2009-05-18","2009-05-19","2009-05-21");
List<String> listB = Arrays.asList("2009-05-18","2009-05-18","2009-05-19","2009-05-19",
                                   "2009-05-20","2009-05-21","2009-05-21","2009-05-22");

List<String> result = listB.stream()
                           .filter(not(new HashSet<>(listA)::contains))
                           .collect(Collectors.toList());

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

Ви не можете легко заперечити предикат без чогось подібного до цього методу утиліти (або явного приведення), оскільки ви не можете безпосередньо викликати посилання на метод заперечення (спочатку потрібно зробити висновок типу).

private static <T> Predicate<T> not(Predicate<T> predicate) {
    return predicate.negate();
}

Якби в потоках був filterOutметод чи щось подібне, це виглядало б приємніше.

Крім того, @Holger дав мені ідею. ArrayListмає свій removeAllметод, оптимізований для багаторазового видалення, він переставляє свої елементи лише один раз. Однак він використовує containsметод, наданий даною колекцією, тому нам потрібно оптимізувати цю частину, якщо вона listAє лише крихітною.

З listAі listBзаявив раніше, це рішення не потребує в Java 8 , і це дуже ефективно.

List<String> result = new ArrayList(listB);
result.removeAll(new HashSet<>(listA));

РЕДАГУВАТИ: оригінальне запитання не вказувало мову. Моя відповідь - на C #.

Натомість для цього слід використовувати HashSet. Якщо вам потрібно використовувати ArrayList, ви можете використовувати такі методи розширення:

var a = arrayListA.Cast<DateTime>();
var b = arrayListB.Cast<DateTime>();    
var c = b.Except(a);

var arrayListC = new ArrayList(c.ToArray());

за допомогою HashSet ...

var a = new HashSet<DateTime>(); // ...and fill it
var b = new HashSet<DateTime>(); // ...and fill it
b.ExceptWith(a); // removes from b items that are in a

Я використовував набори гуави. Різниця .

Параметри безліч і не загальні колекції, але зручний спосіб для створення наборів з будь-якої колекції (з унікальними предметами) є гуава ImmutableSet.copyOf (Iterable).

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

Хоча це дуже давнє запитання в Java 8, ви можете зробити щось подібне

 List<String> a1 = Arrays.asList("2009-05-18", "2009-05-19", "2009-05-21");
 List<String> a2 = Arrays.asList("2009-05-18", "2009-05-18", "2009-05-19", "2009-05-19", "2009-05-20", "2009-05-21","2009-05-21", "2009-05-22");

 List<String> result = a2.stream().filter(elem -> !a1.contains(elem)).collect(Collectors.toList());

Я думаю, ви говорите про C #. Якщо так, ви можете спробувати це

    ArrayList CompareArrayList(ArrayList a, ArrayList b)
    {
        ArrayList output = new ArrayList();
        for (int i = 0; i < a.Count; i++)
        {
            string str = (string)a[i];
            if (!b.Contains(str))
            {
                if(!output.Contains(str)) // check for dupes
                    output.Add(str);
            }
        }
        return output;
    }

Ви просто порівнюєте рядки.

Помістіть значення в ArrayList A як ключі в HashTable A.
Помістіть значення в ArrayList B як ключі в HashTable B.

Потім для кожного ключа в HashTable A видаліть його з HashTable B, якщо він існує.

У HashTable B у вас залишились рядки (ключі), які не були значеннями в ArrayList A.

Приклад C # (3.0) додано у відповідь на запит коду:

List<string> listA = new List<string>{"2009-05-18","2009-05-19","2009-05-21'"};
List<string> listB = new List<string>{"2009-05-18","2009-05-18","2009-05-19","2009-05-19","2009-05-20","2009-05-21","2009-05-21","2009-05-22"};

HashSet<string> hashA = new HashSet<string>();
HashSet<string> hashB = new HashSet<string>();

foreach (string dateStrA in listA) hashA.Add(dateStrA);
foreach (string dateStrB in listB) hashB.Add(dateStrB);

foreach (string dateStrA in hashA)
{
    if (hashB.Contains(dateStrA)) hashB.Remove(dateStrA);
}

List<string> result = hashB.ToList<string>();

Привіт, використовуйте цей клас, він порівняє обидва списки і точно відображає невідповідність чорно-білих обох списків.

import java.util.ArrayList;
import java.util.List;


public class ListCompare {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List<String> dbVinList;
        dbVinList = new ArrayList<String>();
        List<String> ediVinList;
        ediVinList = new ArrayList<String>();           

        dbVinList.add("A");
        dbVinList.add("B");
        dbVinList.add("C");
        dbVinList.add("D");

        ediVinList.add("A");
        ediVinList.add("C");
        ediVinList.add("E");
        ediVinList.add("F");
        /*ediVinList.add("G");
        ediVinList.add("H");
        ediVinList.add("I");
        ediVinList.add("J");*/  

        List<String> dbVinListClone = dbVinList;
        List<String> ediVinListClone = ediVinList;

        boolean flag;
        String mismatchVins = null;
        if(dbVinListClone.containsAll(ediVinListClone)){
            flag = dbVinListClone.removeAll(ediVinListClone);   
            if(flag){
                mismatchVins = getMismatchVins(dbVinListClone);
            }
        }else{
            flag = ediVinListClone.removeAll(dbVinListClone);
            if(flag){
                mismatchVins = getMismatchVins(ediVinListClone);
            }
        }
        if(mismatchVins != null){
            System.out.println("mismatch vins : "+mismatchVins);
        }       

    }

    private static String getMismatchVins(List<String> mismatchList){
        StringBuilder mismatchVins = new StringBuilder();
        int i = 0;
        for(String mismatch : mismatchList){
            i++;
            if(i < mismatchList.size() && i!=5){
                mismatchVins.append(mismatch).append(",");  
            }else{
                mismatchVins.append(mismatch);
            }
            if(i==5){               
                break;
            }
        }
        String mismatch1;
        if(mismatchVins.length() > 100){
            mismatch1 = mismatchVins.substring(0, 99);
        }else{
            mismatch1 = mismatchVins.toString();
        }       
        return mismatch1;
    }

}

ЦЯ РОБОТА ТАКОЖ З Arraylist

    // Create a couple ArrayList objects and populate them
    // with some delicious fruits.
    ArrayList<String> firstList = new ArrayList<String>() {/**
         * 
         */
        private static final long serialVersionUID = 1L;

    {
        add("apple");
        add("orange");
        add("pea");
    }};

    ArrayList<String> secondList = new ArrayList<String>() {

    /**
         * 
         */
        private static final long serialVersionUID = 1L;

    {
        add("apple");
        add("orange");
        add("banana");
        add("strawberry");
    }};

    // Show the "before" lists
    System.out.println("First List: " + firstList);
    System.out.println("Second List: " + secondList);

    // Remove all elements in firstList from secondList
    secondList.removeAll(firstList);

    // Show the "after" list
    System.out.println("Result: " + secondList);