在Java中查找两个ArrayList之间的不同元素

在java中，如何知道2个数组列表之间的不同元素？我需要的是精确的元素，而不是可以使用

removeAll（）

检索的布尔值

---

在for循环的末尾，表中值为0的元素是不同的元素。

如果我正确理解了您的问题，那么下面代码中的以下方法

非重叠

应该可以得到：

<T> Collection<T> union(Collection<T> coll1, Collection<T> coll2) {
    Set<T> union = new HashSet<>(coll1);
    union.addAll(new HashSet<>(coll2));
    return union;
}

<T> Collection<T> intersect(Collection<T> coll1, Collection<T> coll2) {
    Set<T> intersection = new HashSet<>(coll1);
    intersection.retainAll(new HashSet<>(coll2));
    return intersection;
}

<T> Collection<T> nonOverLap(Collection<T> coll1, Collection<T> coll2) {
    Collection<T> result = union(coll1, coll2);
    result.removeAll(intersect(coll1, coll2));
    return result;
}

集合联合（集合coll1、集合coll2）{
Set union=newhashset（coll1）；
union.addAll（新HashSet（coll2））；
回归联盟；
}
集合相交（集合coll1、集合coll2）{
集合交集=新哈希集合（coll1）；
intersection.retainal（新HashSet（coll2））；
折返交叉口；
}
集合不重叠（集合coll1、集合coll2）{
收集结果=并集（coll1，coll2）；
结果：移除所有（相交（coll1，coll2））；
返回结果；
}

导入java.util.ArrayList；
导入java.util.Collection；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Set；
公共类比较实践者{
公共比较实践者（）{
//TODO自动生成的构造函数存根
}
公共静态void main（字符串[]args）{
List ls1=new ArrayList（）；
ls1.添加（“a”）；
ls1.添加（“b”）；
ls1.添加（“c”）；
ls1.添加（“d”）；
List ls2=新的ArrayList（）；
ls2.添加（“a”）；
ls2.添加（“b”）；
ls2.添加（“c”）；
ls2.添加（“d”）；
ls2.添加（“e”）；
Set set1=新的HashSet（）；
set1.addAll（ls1）；
Set set2=新的HashSet（）；
set2.addAll（ls2）；
set2.移除所有（set1）；
//set.addAll（ls1）；
//set.addAll（ls1）；
for（字符串元素：set2）{
System.out.println（differElement.toString（））；
}
}
}    

使用（）：

---

另请参见：Efficient Java，第2版，第47项：了解和使用库（作者仅提到JDK的内置库，但我认为推理也适用于其他库。）

调用方法ReturnArrayListDifferences传递两个数组列表。将返回一个数组列表，它是两个传递的数组列表之间的差异

public ArrayList ReturnArrayListDiffElements(ArrayList arrList1, ArrayList arrList2){   
    ArrayList<String> List1 = new ArrayList<String>();  
    ArrayList<String> List2 = new ArrayList<String>();  
    ArrayList<String> List3 = new ArrayList<String>();  
    ArrayList<String> List4 = new ArrayList<String>();

    List1.addAll(arrList1);     
    List2.addAll(arrList2);

    List3 = ReturnArrayListCommonElements(List1,List2);

    List1.removeAll(List3);     
    List2.removeAll(List3);     
    if(List1.size() > 0){
        List4.add("Distinct elements in Array List 1");     
        List4.addAll(List1);    
    }   
    if(List2.size() > 0){       
        List4.add("Distinct elements in Array List 2");
        List4.addAll(List2);    
    }   

    return List4; 
}

public ArrayList ReturnArrayListCommonElements(ArrayList arrList1, ArrayList arrList2){     
    ArrayList<String> List1 = new ArrayList<String>();  
    ArrayList<String> List2 = new ArrayList<String>();  
    ArrayList<String> List1A = new ArrayList<String>();     
    ArrayList<String> List2A = new ArrayList<String>();     
    ArrayList<String> List1B = new ArrayList<String>();     
    ArrayList<String> List3 = new ArrayList<String>();

    List1.addAll(arrList1);     
    List2.addAll(arrList2);        
    List1A.addAll(arrList1);    
    List2A.addAll(arrList2);    
    List1B.addAll(arrList1);

    int intList1Size, intList2Size;     
    List1.removeAll(List2);
    intList1Size = List1.size();

    List2.removeAll(List1A);    
    intList2Size = List2.size();

    if (intList1Size == 0 && intList2Size ==0) {          
        List3.addAll(List1B);       
        return List3; 
    } else {
        List3.addAll(List1B);       
        List1B.removeAll(List2A);       
        List3.removeAll(List1B);        
        return List3;   
    }
}

public ArrayList returnarraylistdifferencements（ArrayList arrList1，ArrayList arrList2）{
ArrayList List1=新的ArrayList（）；
ArrayList List2=新的ArrayList（）；
ArrayList List3=新的ArrayList（）；
ArrayList List4=新的ArrayList（）；
列表1.addAll（arrList1）；
列表2.addAll（arrList2）；
List3=ReturnArrayListCommonElements（List1，List2）；
清单1.移除所有（清单3）；
清单2.移除所有（清单3）；
如果（List1.size（）>0）{
列表4.添加（“数组列表1中的不同元素”）；
列表4.addAll（列表1）；
}   
如果（List2.size（）>0）{
列表4.添加（“数组列表2中的不同元素”）；
列表4.addAll（列表2）；
}   
返回列表4；
}
public ArrayList ReturnArrayListCommonElements（ArrayList arrList1，ArrayList arrList2）{
ArrayList List1=新的ArrayList（）；
ArrayList List2=新的ArrayList（）；
ArrayList List1A=新的ArrayList（）；
ArrayList List2A=新的ArrayList（）；
ArrayList List1B=新的ArrayList（）；
ArrayList List3=新的ArrayList（）；
列表1.addAll（arrList1）；
列表2.addAll（arrList2）；
列表1a.addAll（arrList1）；
列表2a.addAll（arrList2）；
列表1b.addAll（arrList1）；
int intList1Size、INTLIST2 SIZE；
清单1.移除所有（清单2）；
intList1Size=List1.size（）；
清单2.移除所有（清单1A）；
intList2Size=List2.size（）；
如果（intList1Size==0&&intList2Size==0）{
清单3.addAll（清单1b）；
返回列表3；
}否则{
清单3.addAll（清单1b）；
清单1b.移除所有（清单2a）；
清单3.removeAll（清单1b）；
返回列表3；
}
}

这取决于您要检查的内容

如果要获取两个列表的所有唯一元素（即第一个列表唯一的所有元素和第二个列表唯一的所有元素之和），也可以使用上述析取方法，从：

如果希望仅从一个列表中获取所有唯一元素（即仅存在于一个列表中，但不存在于另一个列表中的元素），也可以使用以下方法从该列表中减去另一个元素：

---

请注意，

removeAll（）

更改了调用方法的列表。因此，如果返回

true

，则表示列表已更改。因此，这种方法并不是完全无用的，它是完美的、简化的，在所有情况下都有效。谢谢

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class CompareTwoList {
    public CompareTwoList() {
        // TODO Auto-generated constructor stub
    }

    public static void main(String[] args) {
        List<String> ls1 = new ArrayList<String>();
        ls1.add("a");
        ls1.add("b");
        ls1.add("c");
        ls1.add("d");

        List<String> ls2 = new ArrayList<String>();
        ls2.add("a");
        ls2.add("b");
        ls2.add("c");
        ls2.add("d");
        ls2.add("e");

        Set<String> set1 = new HashSet<String>();
        set1.addAll(ls1);

        Set<String> set2 = new HashSet<String>();
        set2.addAll(ls2);
        set2.removeAll(set1);

        //set.addAll(ls1);
        //set.addAll(ls1);

        for (String diffElement : set2) {
            System.out.println(diffElement.toString());
        }
    }
}    

CollectionUtils.disjunction(a, b);

public ArrayList ReturnArrayListDiffElements(ArrayList arrList1, ArrayList arrList2){   
    ArrayList<String> List1 = new ArrayList<String>();  
    ArrayList<String> List2 = new ArrayList<String>();  
    ArrayList<String> List3 = new ArrayList<String>();  
    ArrayList<String> List4 = new ArrayList<String>();

    List1.addAll(arrList1);     
    List2.addAll(arrList2);

    List3 = ReturnArrayListCommonElements(List1,List2);

    List1.removeAll(List3);     
    List2.removeAll(List3);     
    if(List1.size() > 0){
        List4.add("Distinct elements in Array List 1");     
        List4.addAll(List1);    
    }   
    if(List2.size() > 0){       
        List4.add("Distinct elements in Array List 2");
        List4.addAll(List2);    
    }   

    return List4; 
}

public ArrayList ReturnArrayListCommonElements(ArrayList arrList1, ArrayList arrList2){     
    ArrayList<String> List1 = new ArrayList<String>();  
    ArrayList<String> List2 = new ArrayList<String>();  
    ArrayList<String> List1A = new ArrayList<String>();     
    ArrayList<String> List2A = new ArrayList<String>();     
    ArrayList<String> List1B = new ArrayList<String>();     
    ArrayList<String> List3 = new ArrayList<String>();

    List1.addAll(arrList1);     
    List2.addAll(arrList2);        
    List1A.addAll(arrList1);    
    List2A.addAll(arrList2);    
    List1B.addAll(arrList1);

    int intList1Size, intList2Size;     
    List1.removeAll(List2);
    intList1Size = List1.size();

    List2.removeAll(List1A);    
    intList2Size = List2.size();

    if (intList1Size == 0 && intList2Size ==0) {          
        List3.addAll(List1B);       
        return List3; 
    } else {
        List3.addAll(List1B);       
        List1B.removeAll(List2A);       
        List3.removeAll(List1B);        
        return List3;   
    }
}

CollectionUtils.disjunction(a, b);

CollectionUtils.subtract(a, b); //gives all unique elements of a that don't exist in b