什麼樣的清單<?>將自動消除重複

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); 

    } 
}