什么样的清单<?>将自动消除重复

Question

什么样的清单会在添加时自动消除重复。

例如如果我添加一个列表1,2,3,4,5,1,2,3 =列表应该只包含1,2,3,4,5

Answer 1

看一看LinkedHashSet

Answer 2

Set将自动消除重复，但它是一个集合，而不是一个列表。

我不认为有一个清单，消除标准库中的重复。

Java 6 SE API文档的Annotated Outline of the Collections Framework页面指出“通常允许重复”。

Answer 3

如果你想消除重复，使用Set

Answer 4

你想要一个集也许，例如HashSet（），而不是一个List？没有列表将消除重复，按照定义列表允许它们。

Answer 5

就像上面的海报说的那样，没有List with Unique处理。

看List (Java Platform SE 6)

set不同，列表通常允许重复的元素。更正式地说，列表通常允许元素e1和e2的对，使得e1.equals（e2），并且它们通常允许多个null元素（如果它们完全允许空元素的话）。有人可能希望通过在用户尝试插入时抛出运行时异常来实现禁止重复的列表，这并不是不可想象的，但我们预计这种用法很少见。

Answer 6

您可以扩展现有的java.util.ArrayList并封装其中的java.util.Set。你应该覆盖所有add(...)，addAll(...)和remove方法与第一次检查，如果一个元素是封装组（的情况下将其添加到列表中的）：

public class ListSet<E> extends ArrayList<E> { 

    private Set<E> set; 

    public ListSet() { 
     set = new HashSet<E>(); 
    } 

    @Override 
    public boolean add(E element) { 
     if(set.add(element)) { 
      super.add(element); 
      return true; 
     } 
     return false; 
    } 

    // other add and remove methods 
} 

编辑

由于@Alnitak提到：不要忘记在删除元素时同步备份HashSet。

Answer 7

这里是ArrayList中的扩展，它不允许重复：

public class NoDupeList<E> extends ArrayList<E>{ 

    private static final long serialVersionUID = -2682691450003022201L; 

    public NoDupeList(){ 
     super(); 
    } 

    public NoDupeList(final Collection<? extends E> c){ 
     super(c instanceof Set<?> ? c : new LinkedHashSet<E>(c)); 
    } 

    public NoDupeList(final int initialCapacity){ 
     super(initialCapacity); 
    } 

    @Override 
    public boolean add(final E e){ 
     return !this.contains(e) && super.add(e); 
    }; 

    @Override 
    public boolean addAll(final Collection<? extends E> c){ 
     final List<E> intermediate = new ArrayList<E>(c); 
     intermediate.removeAll(this); 
     return super.addAll(intermediate); 
    } 

    @Override 
    public void add(final int index, final E element){ 
     if(!this.contains(element)){ 
      super.add(index, element); 
     } 
    }; 

    @Override 
    public E set(final int index, final E element){ 
     if(this.contains(element) && !this.get(index).equals(element)){ 
      throw new IllegalArgumentException("This would cause a duplicate"); 
     } 
     return super.set(index, element); 
    }; 

} 

我不能处理的唯一事情是set()方法。我的解决方案是抛出一个IllegalArgumentException如果这会导致重复，但也许应该通常让这个方法抛出一个UnsupportedOperationException来代替。

总之，这里的测试方法：

@Test 
public void testNoDupeList() throws Exception{ 
    final List<String> list = 
     new NoDupeList<String>(Arrays.asList("abc", "def", "abc")); 
    assertEquals(list, Arrays.asList("abc", "def")); 
    list.addAll(Arrays.asList("abc", "def", "ghi")); 
    assertEquals(list, Arrays.asList("abc", "def", "ghi")); 
    try{ 
     list.set(2, "abc"); 
     fail("This should have caused an Exception"); 
    } catch(final Exception e){} 
}; 

Answer 8

不要像有人建议，实现自己的名单，做重复检查，如果在添加重复返回false（）。

为什么？因为你将打破List接口合同，说：

public boolean add(E e) 
[...] 
Returns: 
     true (as specified by Collections.add()) 

List.add（E E）必须返回true和元素添加到列表中，或抛出异常。列表并不意味着有重复的检查，这是什么集合。

Answer 9

来获取排序并没有重复将它包像这样的实际List最简单的方法：

List<Integer> unique = 
    new ArrayList<Integer>(new TreeSet<Integer>(Arrays.asList(1, 1, 2, 2, 3, 3))); 

注意，当您添加到这个列表重复将不虽然被淘汰，但也许这对你有用。

Answer 10

当时你可以让自己的班级和@Override添加方法到你的班级。 “只看我的代码并练习它”

import java.util.ArrayList; 

import java.util.List; 

class MyList extends ArrayList<Integer> { 

    private static final long serialVersionUID = 1L; 

    @Override 
    public boolean add(Integer element) { 

     if (!found(element)) { 
      super.add(element); 
     } 
     return false; 

    } 
    public boolean found(Integer e) { 
     return equals(e); 
    } 
    public boolean equals(Integer e) { 

     for (int i = 0; i < super.size(); i++) { 
      if (super.get(i).equals(e)) 
       return true; 
     } 

     return false; 
    } 

} 

public class ListRemovingDuplicated { 

    public static void main(String[] abd) { 

     List<Integer> obj = new MyList(); 
     obj.add(10); 
     obj.add(20); 
     obj.add(10); 
     obj.add(10); 
     obj.add(30); 
     System.out.println(obj); 

    } 
}