Java比较两个列表

我有两个列表（不是Java列表，可以说两列）

例如

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

我想要一个返回多少个相同元素的方法。对于此示例，它应该为3，并且应该返回列表的相似值和不同的值。

如果是，我应该使用哈希图，然后用什么方法获得结果？

请帮忙

PS：这不是学校作业：)因此，如果您只是指导我就足够了

编辑

这是两个版本。一种使用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]

如果它不能完全满足您的需求，则可以为您提供一个良好的开始，因此您可以从这里开始。

给读者的问题：您将如何包括所有重复的值？

您可以尝试使用intersection()和subtract()方法CollectionUtils。

intersection()方法为您提供了包含常见元素的集合，而subtract()方法为您提供了所有不常见的元素。

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

这些是真的列表（有序，重复项），还是集合（无序，无重复项）？

因为如果是后者，那么您可以使用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]"

使用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();
}

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

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

• 我不必自己声明任何其他列表/集合
• 我没有更改输入列表
• 非常有效。它检查O（N）复杂度是否相等。

如果不可能具有apache.commons.collections依赖关系，由于效率高，我建议实施以下算法来检查列表是否相等。

简单的解决方案：

    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]

假设hash1和hash2

List< String > sames = whatever
List< String > diffs = whatever

int count = 0;
for( String key : hash1.keySet() )
{
   if( hash2.containsKey( key ) ) 
   {
      sames.add( key );
   }
   else
   {
      diffs.add( key );
   }
}

//sames.size() contains the number of similar elements.

我在List Compare中找到了一个非常基本的List比较示例。 该示例首先验证大小，然后检查另一个列表中特定列表元素的可用性。

public static boolean compareList(List ls1, List ls2){
    return ls1.containsAll(ls2) && ls1.size() == ls2.size() ? true :false;
     }

public static void main(String[] args) {

    ArrayList<String> one = new ArrayList<String>();
    one.add("one");
    one.add("two");
    one.add("six");

    ArrayList<String> two = new ArrayList<String>();
    two.add("one");
    two.add("six");
    two.add("two");

    System.out.println("Output1 :: " + compareList(one, two));

    two.add("ten");

    System.out.println("Output2 :: " + compareList(one, two));
  }