List集合去重方式及效率對比

List集合相信你們在開發過程當中幾乎都會用到。有時候不免會遇到集合裏的數據是重複的，須要進行去除。然而，去重方式有好幾種方式，你用的是哪一種方式呢？去重方式效率是不是最高效、最優的呢？今天就給你們講解一下List集合去重的常見及經常使用的四種方式。

01

實現思路：使用兩個for循環遍歷集合全部元素，而後進行判斷是否有相同元素，若是有，則去除。這種方式是大部分最早想到的，也是最簡單的實現方式。其中，這種方式能夠保證List集合原來的順序不變。

代碼實現：

/**
* notes:使用兩個for循環實現List去重
* @param list
* @return
*/
public static List repeatListWayOne(List<String> list){
   for(int i = 0;i < list.size();i++){
       for(int j = i+1;j < list.size();j++){
           if(list.get(i).equals(list.get(j))){
               list.remove(j);
           }
       }
   }
   return list;
}

 

02

實現思路：咱們知道HashSet實現了Set接口，不容許出現重複元素。能夠基於這個想法，把List集合全部元素存入HashSet對象，接着把List集合元素所有清空，最後把HashSet對象元素所有添加至List集合中，這樣就能夠保證不出現重複元素。而HashSet有一個構造函數，在初始化時能夠直接添加元素。其中，HashSet不能保證順序不變，因此此方式不能保證List集合原來的順序不變。

代碼實現：

/**
* notes:使用HashSet實現List去重
* @param list
* @return
*/
public static List repeatListWayTwo(List<String> list){
  //初始化HashSet對象，並把list對象元素賦值給HashSet對象
  HashSet set = new HashSet(list);
  //把List集合全部元素清空
  list.clear();
  //把HashSet對象添加至List集合
  list.addAll(set);
  return list;
}

 

03

實現思路：TreeSet集合也是實現Set接口，是一個有序的，而且無重複元素集合。同理，咱們能夠根據上面方式二的思想進行去重。其中，去重後的List集合能夠保證和原來的順序一致。

代碼實現：

/**
* notes:使用TreeSet實現List去重
* @param list
* @return
*/
public static List repeatListWayThird(List<String> list){
   //初始化TreeSet對象，並把list對象元素賦值給TreeSet對象
   TreeSet set = new TreeSet(list);
   //把List集合全部元素清空
   list.clear();
   //把TreeSet對象添加至List集合
   list.addAll(set);
   return list;
}

 

04

實現思路：利用List集合contains方法循環遍歷，先建立新的List集合，接着循環遍歷原來的List集合，判斷新集合是否包含有舊集合，若是有，則不添加至新集合，不然添加。最後，把舊集合清空，把新集合元素賦值給舊集合。

代碼實現：

/**
* notes:利用List集合contains方法循環遍歷去重
* @param list
* @return
*/
public static List repeatListWayFourth(List<String> list){
   //新建新List集合，用於存放去重後的元素
   List<String> newList = new ArrayList<String>();
   //循環遍歷舊集合元素
   for(int i = 0; i < list.size(); i++ ){
       //判斷新集合是否包含有，若是不包含有，則存入新集合中
       boolean isContains = newList.contains(list.get(i));
       if(!isContains){
           newList.add(list.get(i));
       }
   }
   //把List集合全部元素清空
   list.clear();
   //把新集合元素添加至List集合
   list.addAll(newList);
   return list;
}

上面給你們介紹了四種List集合去重方式。那麼，哪一種方式效率是最好的呢？下面就演示一下進行對比。

爲了演示方式，隨機生成0-500之間的20000個整數字符串，並存入List集合，並在相應代碼打印相關時間進行對比。其中，隨機生成List集合代碼以下：

/**
* 隨機生成0-500之間的20000個整數字符串，並存入List集合
* @return
*/
public static List<String> getRandomList(){
   List<String> list = new ArrayList<String>();
   //隨機生成20000個整數字符串
   for(int i = 1; i <= 20000; i++){
       //任意取[0,500)之間整數，其中0能夠取到，500取不到
       int number = new Random().nextInt(500);
       String number_str = "geshan"+number;
       list.add(number_str);
   }
   return list;
}

爲了保證List集合元素一致，建立四個List集合，分別對應List去重方式。效率對比代碼以下：

public static void main(String[] args){
   //隨機生成0-500之間的1000個整數字符串List集合
   List<String> list = getRandomList();

   //爲了演示四種方式效率，建立四個List集合，保證List集合元素一致
   //方式一List集合
   List<String> oneList = new ArrayList<>();
   oneList.addAll(list);
   //方式二List集合
   List<String> twoList = new ArrayList<>();
   twoList.addAll(list);
   //方式三List集合
   List<String> thirdList = new ArrayList<>();
   thirdList.addAll(list);
   //方式四List集合
   List<String> fourthList = new ArrayList<>();
   fourthList.addAll(list);

   System.out.println("方式一：使用兩個for循環實現List去重");
   System.out.println("原來集合大小:"+oneList.size()+"，集合元素>>"+oneList);
   Date oneDateBegin = new Date();
   repeatListWayOne(oneList);
   System.out.println("集合去重大小:"+oneList.size()+"，集合元素>>"+oneList);
   Date oneDateEnd = new Date();
   System.out.println("去重所需時間:"+(oneDateEnd.getTime()-oneDateBegin.getTime())+"毫秒");

   System.out.println("方式二：使用HashSet實現List去重");
   System.out.println("原來集合大小:"+twoList.size()+"，集合元素>>"+twoList);
   Date twoDateBegin = new Date();
   repeatListWayTwo(twoList);
   System.out.println("集合去重大小:"+twoList.size()+"，集合元素>>"+twoList);
   Date twoDateEnd = new Date();
   System.out.println("去重所需時間:"+(twoDateEnd.getTime()-twoDateBegin.getTime())+"毫秒");

   System.out.println("方式三：使用TreeSet實現List去重");
   System.out.println("原來集合大小:"+thirdList.size()+"，集合元素>>"+thirdList);
   Date thirdDateBegin = new Date();
   repeatListWayThird(thirdList);
   System.out.println("集合去重大小:"+thirdList.size()+"，集合元素>>"+thirdList);
   Date thirdDateEnd = new Date();
   System.out.println("去重所需時間:"+(thirdDateEnd.getTime()-thirdDateBegin.getTime())+"毫秒");

   System.out.println("方式四：利用List集合contains方法循環遍歷去重");
   System.out.println("原來集合大小:"+fourthList.size()+"，集合元素>>"+fourthList);
   Date fourthDateBegin = new Date();
   repeatListWayFourth(fourthList);
   System.out.println("集合去重大小:"+fourthList.size()+"，集合元素>>"+fourthList);
   Date fourthDateEnd = new Date();
   System.out.println("去重所需時間:"+(fourthDateEnd.getTime()-fourthDateBegin.getTime())+"毫秒");
}

屢次運行結果以下：

第一次四種方式運行時間以下：22三、十、1六、30；

第二次四種方式運行時間以下：16四、十、1七、43；

第三次四種方式運行時間以下：16四、九、1六、37；

綜合代碼及運行時間對比，方式二是最好的去重方式，代碼最簡潔、耗時最短。你平時List集合去重，方式用對了嗎？