日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
探討：Java中刪除數(shù)組中重復元素

這個是一個老問題，但是發(fā)現(xiàn)大多數(shù)人說的還不夠透。小弟就在這里拋磚引玉了，歡迎拍磚.......

問題：比如我有一個數(shù)組（元素個數(shù)為0哈），希望添加進去元素不能重復。

拿到這樣一個問題，我可能會快速的寫下代碼，這里數(shù)組用ArrayList.

 
 
 
    
  
  
  
  1. private static void testListSet(){  
    2. 
  
  
  
  2.         List arrays = new ArrayList(){  
    3. 
  
  
  
  3.             @Override 
    4. 
  
  
  
  4.             public boolean add(String e) {  
    5. 
  
  
  
  5.                 for(String str:this){  
    6. 
  
  
  
  6.                     if(str.equals(e)){  
    7. 
  
  
  
  7.                         System.out.println("add failed !!!  duplicate element");  
    8. 
  
  
  
  8.                         return false;  
    9. 
  
  
  
  9.                     }else{  
    10. 
  
  
  
  10.                         System.out.println("add successed !!!");  
    11. 
  
  
  
  11.                     }  
    12. 
  
  
  
  12.                 }  
    13. 
  
  
  
  13.                 return super.add(e);  
    14. 
  
  
  
  14.             }  
    15. 
  
  
  
  15.         };  
    16. 
  
  
  
  16.                 arrays.add("a");arrays.add("b");arrays.add("c");arrays.add("b");  
    17. 
  
  
  
  17.         for(String e:arrays)  
    18. 
  
  
  
  18.             System.out.print(e);  
    19. 
  
  
  
  19.     } 
    20.

這里我什么都不關，只關心在數(shù)組添加元素的時候做下判斷（當然添加數(shù)組元素只用add方法），是否已存在相同元素，如果數(shù)組中不存在這個元素，就添加到這個數(shù)組中，反之亦然。這樣寫可能簡單，但是面臨龐大數(shù)組時就顯得笨拙：有100000元素的數(shù)組天家一個元素，難道要調(diào)用100000次equal嗎？這里是個基礎。

問題：加入已經(jīng)有一些元素的數(shù)組了，怎么刪除這個數(shù)組里重復的元素呢？

大家知道java中集合總的可以分為兩大類：List與Set。List類的集合里元素要求有序但可以重復，而Set類的集合里元素要求無序但不能重復。那么這里就可以考慮利用Set這個特性把重復元素刪除不就達到目的了，畢竟用系統(tǒng)里已有的算法要優(yōu)于自己現(xiàn)寫的算法吧。

 
 
 
    
  
  
  
  1. public static void removeDuplicate(List list){  
    2. 
  
  
  
  2.    HashSet set = new HashSet(list);  
    3. 
  
  
  
  3.    list.clear();  
    4. 
  
  
  
  4.    list.addAll(set);  
    5. 
  
  
  
  5. }  
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. ivate static People[] ObjData = new People[]{  
    8. 
  
  
  
  8.     new People(0, "a"),new People(1, "b"),new People(0, "a"),new People(2, "a"),new People(3, "c"),  
    9. 
  
  
  
  9. }; 
    10. 
 
 
 
 
 
 
    
  
  
  
  1. public class People{  
    2. 
  
  
  
  2.     private int id;  
    3. 
  
  
  
  3.     private String name;  
    4. 
  
  
  
  4.       
    5. 
  
  
  
  5.     public People(int id,String name){  
    6. 
  
  
  
  6.         this.id = id;  
    7. 
  
  
  
  7.         this.name = name;  
    8. 
  
  
  
  8.     }  
    9. 
  
  
  
  9.       
    10. 
  
  
  
  10.     @Override 
    11. 
  
  
  
  11.     public String toString() {  
    12. 
  
  
  
  12.         return ("id = "+id+" , name "+name);  
    13. 
  
  
  
  13.     }  
    14. 
  
  
  
  14.       
    15. 
  
  
  
  15. } 
    16.

上面的代碼，用了一個自定義的People類，當我添加相同的對象時候（指的是含有相同的數(shù)據(jù)內(nèi)容），調(diào)用removeDuplicate方法發(fā)現(xiàn)這樣并不能解決實際問題，仍然存在相同的對象。那么HashSet里是怎么判斷像個對象是否相同的呢？打開HashSet源碼可以發(fā)現(xiàn)：每次往里面添加數(shù)據(jù)的時候，就必須要調(diào)用add方法：

 
 
 
    
  
  
  
  1.       @Override 
    2. 
  
  
  
  2.      public boolean add(E object) {  
    3. 
  
  
  
  3.          return backingMap.put(object, this) == null;  
    4. 
  
  
  
  4.      } 
    5.

這里的backingMap也就是HashSet維護的數(shù)據(jù)，它用了一個很巧妙的方法，把每次添加的Object當作HashMap里面的KEY，本身HashSet對象當作VALUE。這樣就利用了Hashmap里的KEY***性，自然而然的HashSet的數(shù)據(jù)不會重復。但是真正的是否有重復數(shù)據(jù)，就得看HashMap里的怎么判斷兩個KEY是否相同。

 
 
 
    
  
  
  
  1.         @Override public V put(K key, V value) {  
    2. 
  
  
  
  2. 390         if (key == null) {  
    3. 
  
  
  
  3. 391             return putValueForNullKey(value);  
    4. 
  
  
  
  4. 392         }  
    5. 
  
  
  
  5. 393   
    6. 
  
  
  
  6. 394         int hash = secondaryHash(key.hashCode());  
    7. 
  
  
  
  7. 395         HashMapEntry[] tab = table;  
    8. 
  
  
  
  8. 396         int index = hash & (tab.length - 1);  
    9. 
  
  
  
  9. 397         for (HashMapEntry e = tab[index]; e != null; e = e.next) {  
    10. 
  
  
  
  10. 398             if (e.hash == hash && key.equals(e.key)) {  
    11. 
  
  
  
  11. 399                 preModify(e);  
    12. 
  
  
  
  12. 400                 V oldValue = e.value;  
    13. 
  
  
  
  13. 401                 e.value = value;  
    14. 
  
  
  
  14. 402                 return oldValue;  
    15. 
  
  
  
  15. 403             }  
    16. 
  
  
  
  16. 404         }  
    17. 
  
  
  
  17. 405   
    18. 
  
  
  
  18. 406         // No entry for (non-null) key is present; create one  
    19. 
  
  
  
  19. 407         modCount++;  
    20. 
  
  
  
  20. 408         if (size++ > threshold) {  
    21. 
  
  
  
  21. 409             tab = doubleCapacity();  
    22. 
  
  
  
  22. 410             index = hash & (tab.length - 1);  
    23. 
  
  
  
  23. 411         }  
    24. 
  
  
  
  24. 412         addNewEntry(key, value, hash, index);  
    25. 
  
  
  
  25. 413         return null;  
    26. 
  
  
  
  26. 414     } 
    27.

總的來說，這里實現(xiàn)的思路是：遍歷hashmap里的元素，如果元素的hashcode相等（事實上還要對hashcode做一次處理），然后去判斷KEY的eqaul方法。如果這兩個條件滿足，那么就是不同元素。那這里如果數(shù)組里的元素類型是自定義的話，要利用Set的機制，那就得自己實現(xiàn)equal與hashmap（這里hashmap算法就不詳細介紹了，我也就理解一點）方法了：

 
 
 
    
  
  
  
  1. public class People{  
    2. 
  
  
  
  2.     private int id; //  
    3. 
  
  
  
  3.     private String name;  
    4. 
  
  
  
  4.       
    5. 
  
  
  
  5.     public People(int id,String name){  
    6. 
  
  
  
  6.         this.id = id;  
    7. 
  
  
  
  7.         this.name = name;  
    8. 
  
  
  
  8.     }  
    9. 
  
  
  
  9.       
    10. 
  
  
  
  10.     @Override 
    11. 
  
  
  
  11.     public String toString() {  
    12. 
  
  
  
  12.         return ("id = "+id+" , name "+name);  
    13. 
  
  
  
  13.     }  
    14. 
  
  
  
  14.      
    15. 
  
  
  
  15.     public int getId() {  
    16. 
  
  
  
  16.         return id;  
    17. 
  
  
  
  17.     }  
    18. 
  
  
  
  18.  
    19. 
  
  
  
  19.     public void setId(int id) {  
    20. 
  
  
  
  20.         this.id = id;  
    21. 
  
  
  
  21.     }  
    22. 
  
  
  
  22.  
    23. 
  
  
  
  23.     public String getName() {  
    24. 
  
  
  
  24.         return name;  
    25. 
  
  
  
  25.     }  
    26. 
  
  
  
  26.  
    27. 
  
  
  
  27.     public void setName(String name) {  
    28. 
  
  
  
  28.         this.name = name;  
    29. 
  
  
  
  29.     }  
    30. 
  
  
  
  30.  
    31. 
  
  
  
  31.     @Override 
    32. 
  
  
  
  32.     public boolean equals(Object obj) {  
    33. 
  
  
  
  33.         if(!(obj instanceof People))  
    34. 
  
  
  
  34.             return false;  
    35. 
  
  
  
  35.         People o = (People)obj;  
    36. 
  
  
  
  36.         if(id == o.getId()&&name.equals(o.getName()))  
    37. 
  
  
  
  37.             return true;  
    38. 
  
  
  
  38.         else 
    39. 
  
  
  
  39.             return false;  
    40. 
  
  
  
  40.     }  
    41. 
  
  
  
  41.       
    42. 
  
  
  
  42.     @Override 
    43. 
  
  
  
  43.     public int hashCode() {  
    44. 
  
  
  
  44.         // TODO Auto-generated method stub  
    45. 
  
  
  
  45.         return id;  
    46. 
  
  
  
  46.         //return super.hashCode();  
    47. 
  
  
  
  47.     }  
    48. 
  
  
  
  48. } 
    49.

這里在調(diào)用removeDuplicate(list)方法就不會出現(xiàn)兩個相同的people了。

原文鏈接：http://www.cnblogs.com/slider/archive/2012/01/12/2320313.html

【編輯推薦】

  1. 調(diào)查顯示Java應用服務器市場 開源完勝
  2. 一個Java程序員對2011年的回顧
  3. 用Java GUI編寫的畫板程序
  4. Java的動態(tài)綁定機制
  5. JavaFX 2012：徹底開源

分享文章：探討：Java中刪除數(shù)組中重復元素
當前地址：http://www.5511xx.com/article/dpjpohj.html