List 一定有序，Set不一定無序 ---AND--- 去除List集合中的重複值（6種好用的方法）----ANG--爲什麼Set會去重

0、

Set之所以會去重，和map有很大的關係。
看源碼你會發現HashSet底層使用HashMap存儲
TreeSet底層使用TreeMap存儲
LinkedHashSet底層使用LinkedHashMap存儲

 

拿HashSet爲例子，我們查看add()方法的源碼

 public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

 

 

 

return的map對象其實是 一個HashMap

 

  private transient HashMap<E,Object> map;1

再看map.put(e, PRESENT)
被傳進來的泛型對象當成了Map的鍵，因爲Map鍵值重複的話新的鍵會覆蓋舊的鍵值，所以Set不會重複。
 

1、我們經常聽說List是有序且重複的， Set 是無序不重複的。這裏有個誤區，這裏說的順序有兩個概念，一是按添加的順序排列，二是按自然順序 a-z 排列。 Set 並不是無序的，傳統說的
Set 無序是指 HashSet, 它不能保證元素的添加順序，更不能保證自然順序，而 Set 的其他實現類是可以實現這兩種順序的。

先來看看一段測試代碼：

public class CollectionTest {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<String>();
        arrayList.add("s1");
        arrayList.add("s3");
        arrayList.add("s4");
        arrayList.add("s5");
        arrayList.add("s2");
        System.out.println("ArrayList:==========================");
        for(String arrList : arrayList){
            System.out.println(arrList);
        }
        List<String> linkedList = new LinkedList<String>();
        linkedList.add("s1");
        linkedList.add("s3");
        linkedList.add("s4");
        linkedList.add("s5");
        linkedList.add("s2");
        System.out.println("LinkedList:===========================");
        for(String linkList : linkedList){
            System.out.println(linkList);
        }
        
        Set<String> hashSet = new HashSet<String>();
        hashSet.add("s1");
        hashSet.add("s3");
        hashSet.add("s4");
        hashSet.add("s5");
        hashSet.add("s2");
        System.out.println("HashSet:==============================");
        for(String hashst: hashSet){
            System.out.println(hashst);
        }
        
        Set<String> linkedHashSet = new LinkedHashSet<String>();
        linkedHashSet.add("s1");
        linkedHashSet.add("s3");
        linkedHashSet.add("s4");
        linkedHashSet.add("s5");
        linkedHashSet.add("s2");
        System.out.println("LinkedHashSet:=========================");
        for(String linkedst : linkedHashSet){
            System.out.println(linkedst);
        }
        
        Set<String> treeSet = new TreeSet<String>();
        treeSet.add("s1");
        treeSet.add("s3");
        treeSet.add("s4");
        treeSet.add("s5");
        treeSet.add("s2");
        System.out.println("TreeSet:==============================");
        for(String treest : treeSet){
            System.out.println(treest);
        }
    }

下面輸出的結果：

ArrayList:==========================
s1
s3
s4
s5
s2
LinkedList:===========================
s1
s3
s4
s5
s2
HashSet:==============================
s3
s4
s5
s1
s2
LinkedHashSet:=========================
s1
s3
s4
s5
s2
TreeSet:==============================
s1
s2
s3
s4
s5

怎麼樣看出來了吧，我們通常說的 List 是you序的指的就是最後集合中的元素順序就是按照添加時候的順序排列的（無論是實現類 ArrayList， 還是 LinkedList）。但是我們發現 Set 所謂的無序就是在 HashSet 這個實現類中才會出現的這種情況，而 LinkedHashSet 已經和 List 的結果相同了，再看 TreeSet 實現的功能是根據元素的自然順序排列了

作者：巧克力er
鏈接：https://www.jianshu.com/p/6f0da4dfcb09
來源：簡書
簡書著作權歸作者所有，任何形式的轉載都請聯繫作者獲得授權並註明出處。

 

2、最近項目中需要對list集合中的重複值進行處理，大部分是採用兩種方法，一種是用遍歷list集合判斷後賦給另一個list集合，一種是用賦給set集合再返回給list集合。 

但是賦給set集合後，由於set集合是無序的，原先的順序就打亂了。所以我又想着能不能用set的特性進行去重又不打亂順序呢？ 
試了一下，也是可以的，幾種方法在不同情況下都有各自的優勢。現在將代碼寫出來，比較一下。

    //set集合去重，不打亂順序
    public static void main(String[] args){
         List<String> list  =   new  ArrayList<String>(); 
         list.add("aaa");
         list.add("bbb");
         list.add("aaa");
         list.add("aba");
         list.add("aaa");

         Set set = new  HashSet(); 
         List newList = new  ArrayList(); 
         for (String cd:list) {
            if(set.add(cd)){
                newList.add(cd);
            }
        }
         System.out.println( "去重後的集合： " + newList); 
      }

     //遍歷後判斷賦給另一個list集合
     public static void main(String[] args){
         List<String> list  =   new  ArrayList<String>(); 
         list.add("aaa");
         list.add("bbb");
         list.add("aaa");
         list.add("aba");
         list.add("aaa");

         List<String> newList = new  ArrayList<String>(); 
         for (String cd:list) {
            if(!newList.contains(cd)){
                newList.add(cd);
            }
        }
         System.out.println( "去重後的集合： " + newList); 
      }

    //set去重
    public static void main(String[] args){
         List<String> list  =   new  ArrayList<String>(); 
         list.add("aaa");
         list.add("bbb");
         list.add("aaa");
         list.add("aba");
         list.add("aaa");

        Set set = new  HashSet(); 
         List newList = new  ArrayList(); 
         set.addAll(list);
         newList.addAll(set);

         System.out.println( "去重後的集合： " + newList); 
     }

        //set去重(縮減爲一行)
        public static void main(String[] args){
             List<String> list  =   new  ArrayList<String>(); 
             list.add("aaa");
             list.add("bbb");
             list.add("aaa");
             list.add("aba");
             list.add("aaa");

             List newList = new ArrayList(new HashSet(list)); 

             System.out.println( "去重後的集合： " + newList); 
         }

hashset不進行排序，還有一種方法是用treeset，去重並且按照自然順序排列，將hashset改爲treeset就可以了。（原本的順序是改變的，只是按照字母表順序排列而已）

//去重並且按照自然順序排列
List newList = new ArrayList(new TreeSet(list));