删除重复项（两个值） - ArrayList 中的重复值

Question

我有一个带有以下字符串的ArrayList；

 List<String> e = new ArrayList<String>();
 e.add("123");
 e.add("122");
 e.add("125");
 e.add("123");

我想检查列表中的重复项并将它们从列表中删除。在这种情况下，我的列表将只有两个值，在此示例中它将是值 122 和 125，两个 123 将消失。

最好的方法是什么？我正在考虑使用Set，但这只会删除其中一个重复项。

Answer 1

在 Java 8 中你可以这样做：

e.removeIf(s -> Collections.frequency(e, s) > 1);

如果是 !Java 8，您可以创建 HashMap<String, Integer>。如果字符串已经出现在地图中，则将其 key 加一，否则，将其添加到地图中。

例如：

put("123", 1);

现在让我们假设您再次拥有“123”，您应该获取密钥的计数并将其加一：

put("123", get("aaa") + 1);

现在您可以轻松地在地图上进行迭代并创建一个新的数组列表，其中的键的值为

参考资料：

• ArrayList#removeIf
• Collections#frequency
• HashMap

Answer 2

你也可以在 Java 8 中使用filter

e.stream().filter(s -> Collections.frequency(e, s) == 1).collect(Collectors.toList())

Answer 3

您可以使用HashMap<String, Integer>。

您遍历列表，如果哈希映射不包含该字符串，则将其与值 1 一起添加。

另一方面，如果您已经拥有该字符串，则只需递增计数器。因此，您的字符串的映射如下所示：

{"123", 2}
{"122", 1}
{"125", 1}

然后您将创建一个新列表，其中每个键的值为 1。

Answer 4

这是一个非 Java 8 解决方案，使用映射来计算出现次数：

Map <String,Integer> map = new HashMap<String, Integer>();
for (String s : list){
    if (map.get(s) == null){
      map.put(s, 1);
    } 
    else {
      map.put(s, map.get(s) + 1);
    }
}

List<String> newList = new ArrayList<String>();

// Remove from list if there are multiples of them.
for (Map.Entry<String, String> entry : map.entrySet())
{
  if(entry.getValue() > 1){
    newList.add(entry.getKey());
  }
}

list.removeAll(newList);

Answer 5

ArrayList 中的解决方案

public static void main(String args[]) throws Exception {
      List<String> e = new ArrayList<String>();
      List<String> duplicate = new ArrayList<String>();
      e.add("123");
      e.add("122");
      e.add("125");
      e.add("123");

      for(String str : e){
          if(e.indexOf(str) != e.lastIndexOf(str)){
              duplicate.add(str);
          }
      }

      for(String str : duplicate){
          e.remove(str);              
      }

      for(String str : e){
          System.out.println(str);
      }
  }

Answer 6

使用流的最简单解决方案具有O(n^2) 时间复杂度。如果您在拥有数百万条目的List 上尝试它们，您将等待非常非常长的时间。 O(n) 的解决方案是：

list = list.stream()
           .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()))
           .entrySet()
           .stream()
           .filter(e -> e.getValue() == 1)
           .map(Map.Entry::getKey)
           .collect(Collectors.toList());

在这里，我使用了LinkedHashMap 来维护订单。请注意，静态导入可以简化 collect 部分。

这太复杂了，我认为使用for 循环是解决这个问题的最佳选择。

Map<String, Integer> map = new LinkedHashMap<>();
for (String s : list)
    map.merge(s, 1, Integer::sum);
list = new ArrayList<>();
for (Map.Entry<String, Integer> e : map.entrySet())
    if (e.getValue() == 1)
        list.add(e.getKey());

Answer 7

List<String> e = new ArrayList<String>();
e.add("123");
e.add("122");
e.add("125");
e.add("123");
e.add("125");
e.add("124");
List<String> sortedList = new ArrayList<String>();
for (String current : e){
    if(!sortedList.contains(current)){
        sortedList.add(current);
    }
    else{
        sortedList.remove(current);
    }
}
e.clear();
e.addAll(sortedList);

Answer 8

我是 Google Guava API 的粉丝。使用 Collections2 实用程序和通用 Predicate 实现，可以创建一个实用程序方法来覆盖多种数据类型。

这假设有问题的对象有一个有意义的 .equals 实施

@Test
    public void testTrimDupList() {
        Collection<String> dups = Lists.newArrayList("123", "122", "125", "123");
        dups = removeAll("123", dups);
        Assert.assertFalse(dups.contains("123"));

        Collection<Integer> dups2 = Lists.newArrayList(123, 122, 125,123);
        dups2 = removeAll(123, dups2);
        Assert.assertFalse(dups2.contains(123));
    }

    private <T> Collection<T> removeAll(final T element, Collection<T> collection) {
        return Collections2.filter(collection, new Predicate<T>(){
            @Override
            public boolean apply(T arg0) {
                return !element.equals(arg0);
            }});
    }

多考虑一下

本页中的大多数其他示例都使用 java.util.List API 作为基础集合。我不确定这是否是有意的，但如果返回的元素必须是一个列表，则可以使用另一种中间方法，如下所示。多态性ftw！

@Test
    public void testTrimDupListAsCollection() {
        Collection<String> dups = Lists.newArrayList("123", "122", "125", "123");
        //List used here only to get access to the .contains method for validating behavior.
        dups = Lists.newArrayList(removeAll("123", dups)); 
        Assert.assertFalse(dups.contains("123"));

        Collection<Integer> dups2 = Lists.newArrayList(123, 122, 125,123);
      //List used here only to get access to the .contains method for validating behavior.
        dups2 = Lists.newArrayList(removeAll(123, dups2));
        Assert.assertFalse(dups2.contains(123));
    }

    @Test
    public void testTrimDupListAsList() {
        List<String> dups = Lists.newArrayList("123", "122", "125", "123");
        dups = removeAll("123", dups);
        Assert.assertFalse(dups.contains("123"));

        List<Integer> dups2 = Lists.newArrayList(123, 122, 125,123);
        dups2 = removeAll(123, dups2);
        Assert.assertFalse(dups2.contains(123));
    }

    private <T> List<T> removeAll(final T element, List<T> collection) {
        return Lists.newArrayList(removeAll(element, (Collection<T>) collection));

    }
    private <T> Collection<T> removeAll(final T element, Collection<T> collection) {
        return Collections2.filter(collection, new Predicate<T>(){
            @Override
            public boolean apply(T arg0) {
                return !element.equals(arg0);
            }});
    }

Answer 9

类似这样的东西（使用Set）：

Set<Object> blackList = new Set<>()

public void add(Object object) {
    if (blackList.exists(object)) {
        return;
    }
    boolean notExists = set.add(object);
    if (!notExists) {
       set.remove(object)
       blackList.add(object);
    }
}

Answer 10

如果您要进行设置，则可以通过两组来实现。保持其他集合中的重复值如下：

List<String> duplicateList = new ArrayList<String>();

duplicateList.add("123");
duplicateList.add("122");
duplicateList.add("125");
duplicateList.add("123");
duplicateList.add("127");
duplicateList.add("127");

System.out.println(duplicateList);

Set<String> nonDuplicateList = new TreeSet<String>();
Set<String> duplicateValues = new TreeSet<String>();

if(nonDuplicateList.size()<duplicateList.size()){
    for(String s: duplicateList){
        if(!nonDuplicateList.add(s)){
            duplicateValues.add(s);
        }
    }

    duplicateList.removeAll(duplicateValues);

    System.out.println(duplicateList);
    System.out.println(duplicateValues);
}

输出：原始列表：[123, 122, 125, 123, 127, 127]。删除后
重复：[122, 125] 重复的值：[123, 127]


注意：此解决方案可能未优化。您可能会找到更好的
解决方案比这个。

Answer 11

使用 Guava 库，使用 multiset 和流：

e = HashMultiset.create(e).entrySet().stream()
    .filter(me -> me.getCount() > 1)
    .map(me -> me.getElement())
    .collect(toList());

这对于大型列表（O(n) 具有相当大的常数因子）来说非常漂亮且相当快。但它不会保留顺序（如果需要，可以使用LinkedHashMultiset）并且它会创建一个新的列表实例。

这也很容易概括，例如，删除所有的三元组。

一般来说，多集数据结构对于保存在一个工具箱中非常有用。