Java 如何从2个字符串数组列表中找出差异？

我有两个字符串：

A1=[Rettangolo, Quadrilatero, Rombo, Quadrato]
A2=[Rettangolo, Rettangolo, Rombo, Quadrato]

我想得到这个：“我找到了“四边形”，而不是“Rettangolo”。 如果我使用

removeAll（）

或

retainal（）

它不起作用，因为我有两个“Rettangolo”实例。 事实上，如果我使用

a1.containsAll（a2）

，我得到的是true，我想要的是false

谢谢大家考虑我的请求。

使用ArrayList中的方法。它只删除第一次发生的情况

public static void main(String []args){
        //Create ArrayLists
        String[] A1 = {"Rettangolo", "Quadrilatero", "Rombo", "Quadrato"};
        ArrayList<String> a1=new ArrayList(Arrays.asList(A1));
        String[] A2 ={"Rettangolo", "Rettangolo", "Rombo", "Quadrato"};
        ArrayList<String> a2=new ArrayList(Arrays.asList(A2));
        // Check ArrayLists
        System.out.println("a1 = " + a1);
        System.out.println("a2 = " + a2);
        // Find difference
        for( String s : a1)
            a2.remove(s);
        // Check difference
        System.out.println("a1 = " + a1);
        System.out.println("a2 = " + a2);
}

---

这里有三个解决方案

使用remove方法的实现

public static boolean same(List<String> list1, List<String> list2){
    if (list1.size() != list2.size())
        return false;
    List<String> temp = new ArrayList<String>(list1);
    temp.removeAll(list2);
    return temp.size() == 0;
}

公共静态布尔值相同（列表1、列表2）{
如果（list1.size（）！=list2.size（））
返回false；
列表温度=新的ArrayList（列表1）；
临时移除所有（列表2）；
返回温度大小（）==0；
}

排序然后比较的解决方案

public static boolean same(List<String> list1, List<String> list2){
    if (list1.size() != list2.size())
        return false;
    Collections.sort(list1);
    Collections.sort(list2);
    for (int i=0;i<list1.size();i++){
        if (!list1.get(i).equals(list2.get(i)))
            return false;
    }
    return true;
}

公共静态布尔值相同（列表1、列表2）{
如果（list1.size（）！=list2.size（））
返回false；
Collections.sort（列表1）；
Collections.sort（列表2）；
对于（int i=0；i，这将找到您所解释的特定情况下两个数组之间的交集

String[] A1 = { "Rettangolo", "Quadrilatero", "Rombo", "Quadrato" };
String[] A2 = { "Rettangolo", "Rettangolo", "Rombo", "Quadrato" };
ArrayList<String> a1 = new ArrayList<String>(Arrays.asList(A1));
ArrayList<String> a2 = new ArrayList<String>(Arrays.asList(A2));
a1.removeAll(a2);
System.out.println("I have found " + a1);

String[]A1={“Rettangolo”、“quadralatero”、“Rombo”、“Quadrato”}；
字符串[]A2={“Rettangolo”、“Rettangolo”、“Rombo”、“Quadrato”}；
ArrayList a1=新的ArrayList（Arrays.asList（a1））；
ArrayList a2=新的ArrayList（Arrays.asList（a2））；
a1.拆除所有（a2）；
System.out.println（“我找到了”+a1）；
我希望这会对您有所帮助

    String[] A1 =  {"Rettangolo", "Quadrilatero", "Rombo", "Quadrato"};
    String[] A2 ={"Rettangolo", "Rettangolo", "Rombo", "Quadrato"};

    Set<String> set1 = new HashSet<String>();
    Set<String> set2 = new HashSet<String>();

    set1.addAll(Arrays.asList(A1));
    set2.addAll(Arrays.asList(A2));

    set1.removeAll(set2);
    System.out.println(set1);// ==> [Quadrilatero]

String[]A1={“Rettangolo”、“quadralatero”、“Rombo”、“Quadrato”}；
字符串[]A2={“Rettangolo”、“Rettangolo”、“Rombo”、“Quadrato”}；
Set set1=新的HashSet（）；
Set set2=新的HashSet（）；
set1.addAll（Arrays.asList（A1））；
set2.addAll（Arrays.asList（A2））；
set1.移除所有（set2）；
System.out.println（set1）；//=>[四边形]
这两个课程可能会有所帮助。请告诉我如何进一步改进。
您可以在自己的工作中随意使用下面的代码。
我必须指出，当前的代码不考虑重复的列表元素。

import java.util.List;

public class ListDiff<T> {

    private List<T> removed;
    private List<T> added;

    public ListDiff(List<T> removed, List<T> added) {
        super();
        this.removed = removed;
        this.added = added;
    }

    public ListDiff() {
        super();
    }

    public List<T> getRemoved() {
        return removed;
    }

    public List<T> getAdded() {
        return added;
    }

}

import java.util.List；
公共类ListDiff{
删除私人名单；
增加私人名单；
public ListDiff（删除列表，添加列表）{
超级（）；
这个被移除了；
this.added=added；
}
公共ListDiff（）{
超级（）；
}
公共列表getRemoved（）{
移除返回；
}
公共列表getAdded（）{
增加了退货；
}
}

Util类

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class ListUtil {

    public static <T> ListDiff<T> diff(List<T> one, List<T> two) {

        List<T> removed = new ArrayList<T>();
        List<T> added = new ArrayList<T>();

        for (int i = 0; i < one.size(); i++) {
            T elementOne = one.get(i);
            if (!two.contains(elementOne)) {
                //element in one is removed from two
                removed.add(elementOne);
            }
        }

        for (int i = 0; i < two.size(); i++) {
            T elementTwo = two.get(i);
            if (!one.contains(elementTwo)) {
                //element in two is added.
                added.add(elementTwo);
            }
        }

        return new ListDiff<T>(removed, added);
    }

    public static <T> ListDiff<T> diff(List<T> one, List<T> two, Comparator<T> comparator) {
        List<T> removed = new ArrayList<T>();
        List<T> added = new ArrayList<T>();

        for (int i = 0; i < one.size(); i++) {
            T elementOne = one.get(i);
            boolean found = false;

            //loop checks if element in one is found in two.
            for (int j = 0; j < two.size(); j++) {
                T elementTwo = two.get(j);
                if (comparator.compare(elementOne, elementTwo) == 0) {
                    found = true;
                    break;
                }
            }
            if (found == false) {
                //element is not found in list two. it is removed.
                removed.add(elementOne);
            }
        }

        for (int i = 0; i < two.size(); i++) {
            T elementTwo = two.get(i);
            boolean found = false;

            //loop checks if element in two is found in one.
            for (int j = 0; j < one.size(); j++) {
                T elementOne = one.get(j);
                if (comparator.compare(elementTwo, elementOne) == 0) {
                    found = true;
                    break;
                }
            }
            if (found == false) {
                //it means element has been added to list two. 
                added.add(elementTwo);
            }

        }

        return new ListDiff<T>(removed, added);
    }

    public static void main(String args[]) {
        String[] arr1 = { "london", "newyork", "delhi", "singapore", "tokyo", "amsterdam" };
        String[] arr2 = { "london", "newyork", "delhi", "singapore", "seoul", "bangalore", "oslo" };

        ListDiff<String> ld = ListUtil.diff(Arrays.asList(arr1), Arrays.asList(arr2));
        System.out.println(ld.getRemoved());
        System.out.println(ld.getAdded());

        ld = ListUtil.diff(Arrays.asList(arr1), Arrays.asList(arr2), new Comparator<String>() {
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        }); //sample for using custom comparator
        System.out.println(ld.getRemoved());
        System.out.println(ld.getAdded());
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.Comparator；
导入java.util.List；
公共类ListUtil{
公共静态ListDiff diff（列表一、列表二）{
移除列表=新建ArrayList（）；
添加的列表=新的ArrayList（）；
对于（int i=0；i<1.size（）；i++）{
T elementOne=1.get（i）；
如果（！two.contains（elementOne））{
//一个元素从两个元素中移除
删除。添加（元素一）；
}
}
对于（int i=0；i<2.size（）；i++）{
T元素2=2.get（i）；
如果（！one.contains（elementTwo））{
//添加了两个元素中的元素。
添加。添加（元素二）；
}
}
返回新的ListDiff（删除、添加）；
}
公共静态ListDiff diff（列表一、列表二、比较器）{
移除列表=新建ArrayList（）；
添加的列表=新的ArrayList（）；
对于（int i=0；i<1.size（）；i++）{
T elementOne=1.get（i）；
布尔值=false；
//循环检查一个元素中的元素是否在两个元素中找到。
对于（int j=0；j
数组的长度可以不同吗？您希望A1中的所有元素都以A2的形式出现，无论顺序是什么，还是顺序也很重要？是的，数组大小可以不同。顺序不重要。是的，谢谢。我非常感谢，因为我尝试了在两个列表上迭代删除方法，但运气不好。请在for中切换A1和A2每个循环都可以获得另一个结果。然后您可以将它们添加到输出语句中。在调用（字符串s:a1）

之前，您可以执行

if Collections.disjo
import java.util.List;

public class ListDiff<T> {

    private List<T> removed;
    private List<T> added;

    public ListDiff(List<T> removed, List<T> added) {
        super();
        this.removed = removed;
        this.added = added;
    }

    public ListDiff() {
        super();
    }

    public List<T> getRemoved() {
        return removed;
    }

    public List<T> getAdded() {
        return added;
    }

}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class ListUtil {

    public static <T> ListDiff<T> diff(List<T> one, List<T> two) {

        List<T> removed = new ArrayList<T>();
        List<T> added = new ArrayList<T>();

        for (int i = 0; i < one.size(); i++) {
            T elementOne = one.get(i);
            if (!two.contains(elementOne)) {
                //element in one is removed from two
                removed.add(elementOne);
            }
        }

        for (int i = 0; i < two.size(); i++) {
            T elementTwo = two.get(i);
            if (!one.contains(elementTwo)) {
                //element in two is added.
                added.add(elementTwo);
            }
        }

        return new ListDiff<T>(removed, added);
    }

    public static <T> ListDiff<T> diff(List<T> one, List<T> two, Comparator<T> comparator) {
        List<T> removed = new ArrayList<T>();
        List<T> added = new ArrayList<T>();

        for (int i = 0; i < one.size(); i++) {
            T elementOne = one.get(i);
            boolean found = false;

            //loop checks if element in one is found in two.
            for (int j = 0; j < two.size(); j++) {
                T elementTwo = two.get(j);
                if (comparator.compare(elementOne, elementTwo) == 0) {
                    found = true;
                    break;
                }
            }
            if (found == false) {
                //element is not found in list two. it is removed.
                removed.add(elementOne);
            }
        }

        for (int i = 0; i < two.size(); i++) {
            T elementTwo = two.get(i);
            boolean found = false;

            //loop checks if element in two is found in one.
            for (int j = 0; j < one.size(); j++) {
                T elementOne = one.get(j);
                if (comparator.compare(elementTwo, elementOne) == 0) {
                    found = true;
                    break;
                }
            }
            if (found == false) {
                //it means element has been added to list two. 
                added.add(elementTwo);
            }

        }

        return new ListDiff<T>(removed, added);
    }

    public static void main(String args[]) {
        String[] arr1 = { "london", "newyork", "delhi", "singapore", "tokyo", "amsterdam" };
        String[] arr2 = { "london", "newyork", "delhi", "singapore", "seoul", "bangalore", "oslo" };

        ListDiff<String> ld = ListUtil.diff(Arrays.asList(arr1), Arrays.asList(arr2));
        System.out.println(ld.getRemoved());
        System.out.println(ld.getAdded());

        ld = ListUtil.diff(Arrays.asList(arr1), Arrays.asList(arr2), new Comparator<String>() {
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        }); //sample for using custom comparator
        System.out.println(ld.getRemoved());
        System.out.println(ld.getAdded());
    }
}