java去除数组重复元素的四种方法

[java]  view plain  copy

 print ?

1. package com.yzycool.test;  
2.   
3. import java.util.ArrayList;  
4. import java.util.HashSet;  
5. import java.util.Iterator;  
6. import java.util.LinkedHashSet;  
7. import java.util.List;  
8. import java.util.Set;  
9.   
10. /*去除重复的数组： 
11.  * 方法一：需要一个存储去重后元素的数组，然后两层循环，外层遍历原数组，内容逐个判断是否和之后的元素重复，然后再提出来存入新的数组。方法System.arraycopy(被复制的数组，起始下标，接收的新数组，起始下标，结束下标);可以直接复制数组，既然这样，我就没必要纠结新数组的长度了，直接声明一个跟原数组长度一样的临时数组，只要记录下去重后的元素个数，然后就可以确定去重后数组长度再去将临时数组拷贝到新数组就行了。 
12.  * 方法二:只需要创建一个集合，然后遍历数组逐一放入集合，只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了，然后用toArray转成数组一切搞定。 
13.  * 方法三：最简单的方法就是利用Set集合无序不可重复的特性进行元素过滤。 
14.  * 方法四：链表的哈希集合：有顺序，不重复。 
15.  */  
16.   
17.   
18. public class ShijuanDa1 {  
19.   
20.     public static void main(String[] args) {  
21.         // TODO Auto-generated method stub  
22.         String[] strs ={"2007-1-01","2007-1-06",  
23.                 "2007-1-01","2007-1-08","2007-1-08"};  
24.           
25.         printArr(strs);  
26.           
27.         System.out.println("------------");  
28.           
29.         Object[] newArr = ifRepeat(strs);  
30.           
31.         printArr(newArr);  
32.           
33.         System.out.println("------------");  
34.           
35.         ifRepeat2(strs);  
36.           
37.         System.out.println("------------");  
38.           
39.         Object[] newArr3 = ifRepeat3(strs);  
40.           
41.         printArr(newArr3);  
42.           
43.         System.out.println("------------");  
44.           
45.         ifRepeat4(strs);  
46.   
47.     }  
48.       
49.     public static void printArr(Object[] arr) {  
50.         for (Object object : arr) {  
51.             System.out.println(object);  
52.         }  
53.     }  
54.       
55.       
56.     //方法一：需要传入一个Object数组，然后返回去重后的数组  
57.     public static Object[] ifRepeat(Object[] arr){  
58.         //用来记录去除重复之后的数组长度和给临时数组作为下标索引  
59.         int t = 0;  
60.         //临时数组  
61.         Object[] tempArr = new Object[arr.length];  
62.         //遍历原数组  
63.         for(int i = 0; i < arr.length; i++){  
64.             //声明一个标记，并每次重置  
65.             boolean isTrue = true;  
66.             //内层循环将原数组的元素逐个对比  
67.             for(int j=i+1;j<arr.length;j++){  
68.                 //如果发现有重复元素，改变标记状态并结束当次内层循环  
69.                 if(arr[i]==arr[j]){  
70.                     isTrue = false;  
71.                     break;  
72.                 }  
73.             }  
74.             //判断标记是否被改变，如果没被改变就是没有重复元素  
75.             if(isTrue){  
76.                 //没有元素就将原数组的元素赋给临时数组  
77.                 tempArr[t] = arr[i];  
78.                 //走到这里证明当前元素没有重复，那么记录自增  
79.                 t++;  
80.             }  
81.         }  
82.         //声明需要返回的数组，这个才是去重后的数组  
83.         Object[]  newArr = new Object[t];  
84.         //用arraycopy方法将刚才去重的数组拷贝到新数组并返回  
85.         System.arraycopy(tempArr,0,newArr,0,t);  
86.         return newArr;  
87.     }  
88.       
89.     /* 
90.      * 方法二：只需要创建一个集合，然后遍历数组逐一放入集合，只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了，然后用toArray转成数组一切搞定。 
91.      */  
92.     public static void ifRepeat2(Object[] arr){  
93.         //创建一个集合  
94.         List list = new ArrayList();  
95.         //遍历数组往集合里存元素  
96.         for(int i=0;i<arr.length;i++){  
97.             //如果集合里面没有相同的元素才往里存  
98.             if(!list.contains(arr[i])){  
99.                 list.add(arr[i]);  
100.             }  
101.         }  
102.           
103.         //toArray()方法会返回一个包含集合所有元素的Object类型数组  
104.         Object[] newArr = list.toArray();  
105.         //遍历输出一下测试是否有效  
106.         for(int i=0;i<newArr.length;i++){  
107.             System.out.println(" "+newArr[i]);  
108.         }  
109.   
110.     }  
111.     /* 
112.      * 方法三：最简单的方法就是利用Set集合无序不可重复的特性进行元素过滤。 
113.      */  
114.     public static Object[] ifRepeat3(Object[] arr){  
115.         //实例化一个set集合  
116.         Set set = new HashSet();  
117.         //遍历数组并存入集合,如果元素已存在则不会重复存入  
118.         for (int i = 0; i < arr.length; i++) {  
119.             set.add(arr[i]);  
120.         }  
121.         //返回Set集合的数组形式  
122.         return set.toArray();  
123.     }  
124.       
125.     /* 
126.      * 方法四：链表的哈希集合：有顺序，不重复。 
127.      */  
128.     public static void ifRepeat4(Object[] arr){  
129.           
130.         LinkedHashSet<Object> haoma = new LinkedHashSet<Object>();  
131.         for (int i = 0; i < arr.length; i++) {  
132.             haoma.add(arr[i]);  
133.         }  
134.           
135.         // 创建迭代器  
136.         Iterator<Object> iterator = haoma.iterator();  
137.         int a = 0;  
138.         // 迭代集合  
139.         while (iterator.hasNext()) { // true  
140.             Object c = iterator.next();  
141.               
142.             System.out.println(c);  
143.         }  
144.           
145.           
146.     }  
147.       
148.   
149. }