Question

我有一个数组，比如List<Integer> 139, 127, 127, 139, 130

如何删除它的重复并保持其顺序不变？即139, 127, 130

Answer 1

使用java.util.LinkedHashSet的实例。

Set<Integer> set = new LinkedHashSet<>(list);

Answer 2

从列表中构建Set - “不包含重复元素的集合”：

Set<Integer> yourSet = new HashSet<Integer>(yourList);

然后将其转换回您想要的任何内容。

注意：如果您想保留订单，请改用LinkedHashSet。

Answer 3

没有LinkedHashSet的开销（将HashSet用于可见的元素，而不是更快）：

List<Integer> noDuplicates = list
        .stream()
        .distinct()
        .collect(Collectors.toList());

请注意，订单由Stream.distinct()合同保证：

对于有序流，不同元素的选择是稳定的（对于重复的元素，该元素在遭遇中首先出现订单被保留。）

Answer 4

这个单行：

yourList = new ArrayList<Integer>(new LinkedHashSet<Integer>(yourList))

Answer 5

使用LinkedHashSet删除重复并维护订单。

Answer 6

正如我无法推断的那样，你需要保留插入顺序，这与@Maroun Maroun编写的内容有关，使用set，但像LinkedHashSet<E> whitch这样的特殊实现完全符合你需要的东西。

Answer 7

遍历数组（通过迭代器，而不是foreach）并删除重复项。使用set查找重复项。

OR

遍历数组并将所有元素添加到LinkedHashSet，它不允许重复并保持元素的顺序。然后清除数组，遍历set并将每个元素添加到数组中。

Answer 8

尽管将ArrayList转换为HashSet可以有效地删除重复项，但如果您需要保留插入顺序，我建议您使用此变体

// list是一些字符串列表

   Set<String> s = new LinkedHashSet<String>(list);

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

Answer 9

有两种方式：

仅使用唯一的整数创建新列表

（与Maroun Maroun一样回答）

你可以用这样的O（n.n / 2）这两个嵌套的fors做到这一点：

List<int> src,dst;
// src is input list
// dst is output list
dst.allocate(src.num); // prepare size to avoid slowdowns by reallocations
dst.num=0;             // start from empty list
for (int i=0;i<src.num;i++)
 {
 int e=1;
 for (int j=0;i<dst.num;i++)
  if (src[i]==dst[j]) { e=0; break; }
 if (e) dst.add(src[i]);
 }

您可以选择重复的项目并删除它们......带有标记删除的O（2.n）
- 这种方式要快得多，但你需要整个int范围的内存表
- 如果您使用数字＆lt; 0,10000＆gt;然后它将需要BYTE cnt [10001]
- 如果您使用数字＆lt; -10000,10000＆gt;然后它将需要BYTE cnt [20002]
- 对于像这样的小范围是可以的，但如果你必须使用32位范围，它将需要4GB !!!
- 有点位打包，每个值可以有2位，所以它只有1GB，但这对我来说仍然太多了
- 好现在如何检查两面性......
```
List<WORD> src;  // src is input list
BYTE cnt[65536]; // count usage for all used numbers
int i;
for (i=0;i<65536;i++) cnt[i]=0; // clear the count for all numbers
for (i=0;i<src.num;i++)         // compute the count for used numbers in the list  
 if (cnt[src[i]]!=255) 
  cnt[src[i]]++;
```
- 在此之后，如果（cnt [i]＆gt; 1）
- 所以现在我们要删除重复的项目（除了一个之外的所有项目）
- 这样做改变cnt []就像这样
```
for (i=0;i<65536;i++) if (cnt[i]>1) cnt[i]=1; else cnt[i]=0;
```
- 现在好了，删除部分：
```
for (i=0;i<src.num;i++)         
 if (cnt[src[i]]==1) cnt[src[i]]=2; // do not delete the first time
  else if (cnt[src[i]]==2)          // but all the others yes
   { 
   src.del(i);
   i--;                             // indexes in src changed after delete so recheck for the same index again
   }
```
您可以将两种方法结合起来
从列表中删除项目很慢
- 但可以通过向项目添加删除标志来加快速度
- 而不是删除只设置标志
- 并且在标记所有要删除的项目之后，只需立即删除下摆O（n）

PS。很抱歉非标准列表使用，但我认为代码是可以理解的，如果不评论我，我回复

PPS。与签名值一起使用时，不要忘记将地址移动一半!!!！

Answer 10

下面我给出了实现泛型函数的示例示例，以便从arraylist中删除重复并同时维护该顺序。

import java.util.*;
public class Main {
    //Generic function to remove duplicates in list and maintain order
    private static <E> List<E> removeDuplicate(List<E> list) {
        Set<E> array = new LinkedHashSet<E>();
        array.addAll(list);
        return new ArrayList<>(array);
    }
    public static void main(String[] args) {
        //Print [2, 3, 5, 4]
        System.out.println(removeDuplicate(Arrays.asList(2,2,3,5, 3, 4)));
        //Print [AB, BC, CD]
        System.out.println(removeDuplicate(Arrays.asList("AB","BC","CD","AB")));
    }
}

Answer 11

方法1：在Python中=＆gt;使用集合和列表理解

a= [139, 127, 127, 139, 130]

print(a)
seen =set()
aa = [ch  for ch in a if ch not in seen and not seen.add(ch)]
print(aa)

方法2：

aa = list(set(a))
print(aa)

在Java中：使用Set并创建一个新的ArrayList

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

int[] a = {139, 127, 127, 139, 130};
List<Integer> list1 = new ArrayList<>();

Set<Integer> set = new LinkedHashSet<Integer>();
for( int ch  : a) {
    if(!set.contains(ch)) {
        set.add(ch);
    }


}//for
set.forEach( (k) -> list1.add(k));
System.out.println(list1);

}
    }

Answer 12

List<Integer> items = list.stream()
    .distinct()
    .collect(Collectors.toList());

删除数组中的重复项而不更改元素的顺序

12 个答案: