HashSet去重

Java代码  

1. package com.huawei.test;   
2.   
3. import java.util.Arrays;   
4. import java.util.Collection;   
5. import java.util.HashSet;   
6. import java.util.LinkedHashSet;   
7. import java.util.Set;   
8.   
9. public class FindDups   
10. {   
11.     /**  
12.      * 去重1（重复数据只保留一条）  
13.      * 去重后保持原有顺序  
14.      * @param arr 数组  
15.      */  
16.     public static void findDup1(String[] arr)   
17.     {   
18.         Collection<string> noDups = new LinkedHashSet<string>(Arrays.asList(arr));   
19.         System.out.println("(LinkedHashSet) distinct words:    " + noDups);   
20.     }   
21.   
22.     /**  
23.      * 去重2（重复数据只保留一条）  
24.      * 去重后顺序打乱  
25.      * @param arr 数组  
26.      */  
27.     public static void findDup2(String[] arr)   
28.     {   
29.         Collection<string> noDups = new HashSet<string>(Arrays.asList(arr));   
30.         System.out.println("(HashSet) distinct words:    " + noDups);   
31.     }   
32.        
33.     /**  
34.      * 去重3（重复数据只保留一条）  
35.      * 去重后顺序打乱  
36.      * @param arr 数组  
37.      */  
38.     public static void findDup3(String[] arr)   
39.     {   
40.         Set<string> s = new HashSet<string>();   
41.         for (String a : arr)   
42.         {   
43.             if (!s.add(a))   
44.             {   
45.                 System.out.println("Duplicate detected: " + a);   
46.             }   
47.         }   
48.         System.out.println(s.size() + " distinct words: " + s);   
49.            
50.     }   
51.        
52.     /**  
53.      * 去重4(相同的数据一条都不保留，取唯一)  
54.      * 去重后顺序打乱  
55.      * @param arr 数组  
56.      */  
57.     public static void findDup4(String[] arr)   
58.     {   
59.         Set<string> uniques = new HashSet<string>();   
60.         Set<string> dups = new HashSet<string>();   
61.            
62.         for (String a : arr)   
63.         {   
64.             {   
65.                 if (!uniques.add(a))   
66.                     dups.add(a);   
67.             }   
68.         }   
69.         // Destructive set-difference   
70.         uniques.removeAll(dups);   
71.            
72.         System.out.println("Unique words:    " + uniques);   
73.         System.out.println("Duplicate words: " + dups);   
74.     }   
75.        
76.     /**  
77.      * 测试主方法  
78.      * @param args 参数  
79.      */  
80.     public static void main(String[] args)   
81.     {   
82.         String[] arr = new String[] {"i", "think", "i", "am", "the", "best"};   
83.         findDup1(arr);   
84.         findDup2(arr);   
85.         findDup3(arr);   
86.         findDup4(arr);   
87.     }   
88. }  

package com.huawei.test;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class FindDups
{
    /**
     * 去重1（重复数据只保留一条）
     * 去重后保持原有顺序
     * @param arr 数组
     */
    public static void findDup1(String[] arr)
    {
        Collection<string> noDups = new LinkedHashSet<string>(Arrays.asList(arr));
        System.out.println("(LinkedHashSet) distinct words:    " + noDups);
    }

    /**
     * 去重2（重复数据只保留一条）
     * 去重后顺序打乱
     * @param arr 数组
     */
    public static void findDup2(String[] arr)
    {
        Collection<string> noDups = new HashSet<string>(Arrays.asList(arr));
        System.out.println("(HashSet) distinct words:    " + noDups);
    }
    
    /**
     * 去重3（重复数据只保留一条）
     * 去重后顺序打乱
     * @param arr 数组
     */
    public static void findDup3(String[] arr)
    {
        Set<string> s = new HashSet<string>();
        for (String a : arr)
        {
            if (!s.add(a))
            {
                System.out.println("Duplicate detected: " + a);
            }
        }
        System.out.println(s.size() + " distinct words: " + s);
        
    }
    
    /**
     * 去重4(相同的数据一条都不保留，取唯一)
     * 去重后顺序打乱
     * @param arr 数组
     */
    public static void findDup4(String[] arr)
    {
        Set<string> uniques = new HashSet<string>();
        Set<string> dups = new HashSet<string>();
        
        for (String a : arr)
        {
            {
                if (!uniques.add(a))
                    dups.add(a);
            }
        }
        // Destructive set-difference
        uniques.removeAll(dups);
        
        System.out.println("Unique words:    " + uniques);
        System.out.println("Duplicate words: " + dups);
    }
    
    /**
     * 测试主方法
     * @param args 参数
     */
    public static void main(String[] args)
    {
        String[] arr = new String[] {"i", "think", "i", "am", "the", "best"};
        findDup1(arr);
        findDup2(arr);
        findDup3(arr);
        findDup4(arr);
    }
}