如何从ArrayList中删除重复的元素？

Question

我有一个ArrayList<String>,我想从中删除重复的字符串.我怎样才能做到这一点？

Answer 1

如果您不想在a中重复Collection,您应该考虑为什么使用Collection允许重复的重复项.删除重复元素的最简单方法是将内容添加到Set(不允许重复),然后将其添加Set回ArrayList:

Set<String> set = new HashSet<>(yourList);
yourList.clear();
yourList.addAll(set);

当然,这破坏了元素的排序ArrayList.

Answer 2

虽然转换ArrayList为HashSet有效删除重复项,但如果您需要保留插入顺序,我建议您使用此变体

// list is some List of Strings
Set<String> s = new LinkedHashSet<>(list);

然后,如果您需要返回List引用,则可以再次使用转换构造函数.

Answer 3

在Java 8中:

List<String> deduped = list.stream().distinct().collect(Collectors.toList());

请注意,应该尊重列表成员的hashCode-equals合同,以使过滤正常工作.

Answer 4

假设我们有一个String类似的列表:

List<String> strList = new ArrayList<>(5);
// insert up to five items to list.        

然后我们可以通过多种方式删除重复的元素.

在Java 8之前

List<String> deDupStringList = new ArrayList<>(new HashSet<>(strList));

注意:如果我们想要维护插入顺序,那么我们需要使用LinkedHashSet代替HashSet

使用番石榴

List<String> deDupStringList2 = Lists.newArrayList(Sets.newHashSet(strList));

使用Java 8

List<String> deDupStringList3 = strList.stream().distinct().collect(Collectors.toList());

注意: 如果我们想要在特定列表实现中收集结果,例如,LinkedList我们可以将上面的示例修改为:

List<String> deDupStringList3 = strList.stream().distinct()
                 .collect(Collectors.toCollection(LinkedList::new));

我们也parallelStream可以在上面的代码中使用,但它可能不会给出预期的性能优势.查看此问题了解更多信息.

Answer 5

如果您不想要重复,请使用Set而不是a List.要将a转换List为a,Set您可以使用以下代码:

// list is some List of Strings
Set<String> s = new HashSet<String>(list);

如果真的有必要,你可以使用相同的结构将一个Set回转换成一个List.

Answer 6

你也可以这样做,并保持秩序:

// delete duplicates (if any) from 'myArrayList'
myArrayList = new ArrayList<String>(new LinkedHashSet<String>(myArrayList));

Answer 7

这是一种不影响列表排序的方法:

ArrayList l1 = new ArrayList();
ArrayList l2 = new ArrayList();

Iterator iterator = l1.iterator();

while (iterator.hasNext()) {
    YourClass o = (YourClass) iterator.next();
    if(!l2.contains(o)) l2.add(o);
}

l1是原始列表,l2是没有重复项目的列表(确保YourClass根据你想要的平等对应的方法)

Answer 8

Java 8流提供了一种从列表中删除重复元素的非常简单的方法.使用不同的方法.如果我们有一个城市列表,并且我们想从该列表中删除重复项,则可以在一行中完成 -

 List<String> cityList = new ArrayList<>();
 cityList.add("Delhi");
 cityList.add("Mumbai");
 cityList.add("Bangalore");
 cityList.add("Chennai");
 cityList.add("Kolkata");
 cityList.add("Mumbai");

 cityList = cityList.stream().distinct().collect(Collectors.toList());

如何从arraylist中删除重复的元素

Answer 9

还有ImmutableSet从番石榴作为一个选项(这里是文档):

ImmutableSet.copyOf(list);

Answer 10

可以在不使用HashSet或一个 arraylist的情况下从arraylist中删除重复项.

试试这个代码..

    ArrayList<String> lst = new ArrayList<String>();
    lst.add("ABC");
    lst.add("ABC");
    lst.add("ABCD");
    lst.add("ABCD");
    lst.add("ABCE");

    System.out.println("Duplicates List "+lst);

    Object[] st = lst.toArray();
      for (Object s : st) {
        if (lst.indexOf(s) != lst.lastIndexOf(s)) {
            lst.remove(lst.lastIndexOf(s));
         }
      }

    System.out.println("Distinct List "+lst);

输出是

Duplicates List [ABC, ABC, ABCD, ABCD, ABCE]
Distinct List [ABC, ABCD, ABCE]

Answer 11

这可以解决问题:

private List<SomeClass> clearListFromDuplicateFirstName(List<SomeClass> list1) {

     Map<String, SomeClass> cleanMap = new LinkedHashMap<String, SomeClass>();
     for (int i = 0; i < list1.size(); i++) {
         cleanMap.put(list1.get(i).getFirstName(), list1.get(i));
     }
     List<SomeClass> list = new ArrayList<SomeClass>(cleanMap.values());
     return list;
}

Answer 12

可能有点矫枉过正,但我​​喜欢这种孤立的问题.:)

此代码使用临时Set(用于唯一性检查),但直接删除原始列表中的元素.由于ArrayList中的元素移除会导致大量的数组复制,因此避免了remove(int)方法.

public static <T> void removeDuplicates(ArrayList<T> list) {
    int size = list.size();
    int out = 0;
    {
        final Set<T> encountered = new HashSet<T>();
        for (int in = 0; in < size; in++) {
            final T t = list.get(in);
            final boolean first = encountered.add(t);
            if (first) {
                list.set(out++, t);
            }
        }
    }
    while (out < size) {
        list.remove(--size);
    }
}

虽然我们在这里,但这里是LinkedList的一个版本(好多了!):

public static <T> void removeDuplicates(LinkedList<T> list) {
    final Set<T> encountered = new HashSet<T>();
    for (Iterator<T> iter = list.iterator(); iter.hasNext(); ) {
        final T t = iter.next();
        final boolean first = encountered.add(t);
        if (!first) {
            iter.remove();
        }
    }
}

使用标记界面为List提供统一的解决方案:

public static <T> void removeDuplicates(List<T> list) {
    if (list instanceof RandomAccess) {
        // use first version here
    } else {
        // use other version here
    }
}

编辑:我想泛型的东西在这里并没有真正增加任何价值..哦,好吧.:)

Answer 13

public static void main(String[] args){
    ArrayList<Object> al = new ArrayList<Object>();
    al.add("abc");
    al.add('a');
    al.add('b');
    al.add('a');
    al.add("abc");
    al.add(10.3);
    al.add('c');
    al.add(10);
    al.add("abc");
    al.add(10);
    System.out.println("Before Duplicate Remove:"+al);
    for(int i=0;i<al.size();i++){
        for(int j=i+1;j<al.size();j++){
            if(al.get(i).equals(al.get(j))){
                al.remove(j);
                j--;
            }
        }
    }
    System.out.println("After Removing duplicate:"+al);
}

Answer 14

如果您使用模型类型 List< T>/ArrayList< T> 。希望，对你有帮助。

这是我的代码，没有使用任何其他数据结构，如集合或哈希图

for (int i = 0; i < Models.size(); i++){
for (int j = i + 1; j < Models.size(); j++) {       
 if (Models.get(i).getName().equals(Models.get(j).getName())) {    
 Models.remove(j);
   j--;
  }
 }
}

Answer 15

如果你愿意使用第三方库,你可以使用的方法distinct()在Eclipse中集(原GS集合).

ListIterable<Integer> integers = FastList.newListWith(1, 3, 1, 2, 2, 1);
Assert.assertEquals(
    FastList.newListWith(1, 3, 2),
    integers.distinct());

使用distinct()而不是转换为Set然后返回List 的优点是distinct()保留原始List的顺序,保留每个元素的第一次出现.它是通过使用Set和List实现的.

MutableSet<T> seenSoFar = UnifiedSet.newSet();
int size = list.size();
for (int i = 0; i < size; i++)
{
    T item = list.get(i);
    if (seenSoFar.add(item))
    {
        targetCollection.add(item);
    }
}
return targetCollection;

如果无法将原始List转换为Eclipse Collections类型,则可以使用ListAdapter获取相同的API.

MutableList<Integer> distinct = ListAdapter.adapt(integers).distinct();

注意:我是Eclipse Collections的提交者.