Java比较两个列表

Question

我有两个列表(不是java列表,你可以说两列)

例如

**List 1**            **Lists 2**
  milan                 hafil
  dingo                 iga
  iga                   dingo
  elpha                 binga
  hafil                 mike
  meat                  dingo
  milan
  elpha
  meat
  iga                   
  neeta.peeta    

我想要一个返回多少元素相同的方法.对于这个例子,它应该是3,它应该返回类似的列表和不同值的值.

如果是,我应该使用hashmap然后用什么方法来获取我的结果？

请帮忙

PS:这不是学校的任务:)所以如果你只是指导我就足够了

Answer 1

编辑

这是两个版本.一个使用ArrayList和其他使用HashSet

比较它们并从中创建您自己的版本,直到您得到您需要的.

这应该足以涵盖:

PS:这不是学校的任务:)所以如果你只是指导我就足够了

你问题的一部分.

继续原来的答案:

您可以使用java.util.Collection 和/或 java.util.ArrayList为此.

该中的retainAll方法执行以下操作:

仅保留此集合中包含在指定集合中的元素

看这个样本:

import java.util.Collection;
import java.util.ArrayList;
import java.util.Arrays;

public class Repeated {
    public static void main( String  [] args ) {
        Collection listOne = new ArrayList(Arrays.asList("milan","dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta"));
        Collection listTwo = new ArrayList(Arrays.asList("hafil", "iga", "binga", "mike", "dingo"));

        listOne.retainAll( listTwo );
        System.out.println( listOne );
    }
}

编辑

对于第二部分(类似的值),您可以使用removeAll方法:

删除也包含在指定集合中的所有此集合的元素.

第二个版本还为您提供了类似的值和重复处理(通过丢弃它们).

这次Collection可能是a Set而不是a List(不同的是,Set不允许重复值)

import java.util.Collection;
import java.util.HashSet;
import java.util.Arrays;

class Repeated {
      public static void main( String  [] args ) {

          Collection<String> listOne = Arrays.asList("milan","iga",
                                                    "dingo","iga",
                                                    "elpha","iga",
                                                    "hafil","iga",
                                                    "meat","iga", 
                                                    "neeta.peeta","iga");

          Collection<String> listTwo = Arrays.asList("hafil",
                                                     "iga",
                                                     "binga", 
                                                     "mike", 
                                                     "dingo","dingo","dingo");

          Collection<String> similar = new HashSet<String>( listOne );
          Collection<String> different = new HashSet<String>();
          different.addAll( listOne );
          different.addAll( listTwo );

          similar.retainAll( listTwo );
          different.removeAll( similar );

          System.out.printf("One:%s%nTwo:%s%nSimilar:%s%nDifferent:%s%n", listOne, listTwo, similar, different);
      }
}

输出:

$ java Repeated
One:[milan, iga, dingo, iga, elpha, iga, hafil, iga, meat, iga, neeta.peeta, iga]

Two:[hafil, iga, binga, mike, dingo, dingo, dingo]

Similar:[dingo, iga, hafil]

Different:[mike, binga, milan, meat, elpha, neeta.peeta]

如果它不能完全满足您的需求,它会给您一个良好的开端,因此您可以从这里开始处理.

读者的问题:您如何包含所有重复的值？

Answer 2

你可以尝试intersection()和subtract()方法CollectionUtils.

intersection()method为您提供了一个包含公共元素的集合,该subtract()方法为您提供了所有不常见的元素.

他们还应该照顾类似的元素

Answer 3

这些是真正的列表(有序,有重复),还是它们是集合(无序,没有重复)？

因为如果它是后者,那么你可以使用,比如说a java.util.HashSet<E>和使用方便的预期线性时间retainAll.

    List<String> list1 = Arrays.asList(
        "milan", "milan", "iga", "dingo", "milan"
    );
    List<String> list2 = Arrays.asList(
        "hafil", "milan", "dingo", "meat"
    );

    // intersection as set
    Set<String> intersect = new HashSet<String>(list1);
    intersect.retainAll(list2);
    System.out.println(intersect.size()); // prints "2"
    System.out.println(intersect); // prints "[milan, dingo]"

    // intersection/union as list
    List<String> intersectList = new ArrayList<String>();
    intersectList.addAll(list1);
    intersectList.addAll(list2);
    intersectList.retainAll(intersect);
    System.out.println(intersectList);
    // prints "[milan, milan, dingo, milan, milan, dingo]"

    // original lists are structurally unmodified
    System.out.println(list1); // prints "[milan, milan, iga, dingo, milan]"
    System.out.println(list2); // prints "[hafil, milan, dingo, meat]"

Answer 4

如果您正在寻找一种方便的方法来测试两个集合的相等性，您可以使用org.apache.commons.collections.CollectionUtils.isEqualCollection，它会比较两个集合而不考虑排序。

Answer 5

简单的解决方案：-

    List<String> list = new ArrayList<String>(Arrays.asList("a", "b", "d", "c"));
    List<String> list2 = new ArrayList<String>(Arrays.asList("b", "f", "c"));

    list.retainAll(list2);
    list2.removeAll(list);
    System.out.println("similiar " + list);
    System.out.println("different " + list2);

输出 ：-

similiar [b, c]
different [f]

Answer 6

在所有方法中，我发现使用org.apache.commons.collections.CollectionUtils#isEqualCollection是最好的方法。原因如下——

• 我不必自己声明任何其他列表/设置
• 我没有改变输入列表
• 这是非常有效的。它检查 O(N) 复杂度的相等性。

如果不可能apache.commons.collections作为依赖项，我会建议实施它遵循的算法来检查列表的相等性，因为它的效率。

Answer 7

使用Java 8 removeIf

public int getSimilarItems(){
    List<String> one = Arrays.asList("milan", "dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta");
    List<String> two = new ArrayList<>(Arrays.asList("hafil", "iga", "binga", "mike", "dingo")); //Cannot remove directly from array backed collection
    int initial = two.size();

    two.removeIf(one::contains);
    return initial - two.size();
}