如何计算两个 ArrayList 之间的差异？

Question

我有两个 ArrayList。

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 中不存在的 List。

ArrayList 结果应该是：

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

如何比较？

Answer 1

在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]

Answer 2

你已经有了正确的答案。 如果您想在列表（集合）之间进行更复杂和有趣的操作，请使用apache commons collections (CollectionUtils) 它允许您进行合取/析取、查找交集、检查一个集合是否是另一个集合的子集以及其他好东西。

Answer 3

在带有流的 Java 8 中，实际上非常简单。编辑：可以在没有流的情况下高效，见下文。

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

请注意，哈希集只创建一次：方法引用与其包含方法相关联。对 lambda 执行相同操作需要将集合放入变量中。制作变量并不是一个坏主意，尤其是当您发现它不美观或难以理解时。

如果没有这种实用方法（或显式强制转换），您将无法轻松 negate the predicate，因为您无法直接调用否定方法引用（首先需要类型推断）。

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

Answer 4

编辑：原始问题未指定语言。我的答案是 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

Answer 5

我用过番石榴Sets.difference。

参数是集合而不是一般集合，但是从任何集合（具有唯一项）创建集合的便捷方法是 Guava ImmutableSet.copyOf(Iterable)。

（我第一次发布了这个on a related/dupe question，但我也在这里复制它，因为我觉得这是一个很好的选择，但到目前为止还没有。）

Answer 6

虽然这是 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());

Answer 7

我猜你说的是 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;
    }

Answer 8

你只是在比较字符串。

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

Answer 9

你好，使用这个类，这将比较两个列表并准确显示两个列表的不匹配。

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

}

Answer 10

这也适用于 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);