两个列表比较取相同值

1. import java.io.File;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileOutputStream;  
4. import java.io.IOException;  
5. import java.io.OutputStreamWriter;  
6. import java.util.ArrayList;  
7. import java.util.Arrays;  
8. import java.util.LinkedHashSet;  
9. import java.util.List;  
10. import java.util.Random;  
11.   
12.   
13. public class ListCompare {  
14.       
15.     //传入两个元素之间可相互比较的列表, 从两个列表中选择相同的元素组成新列表返回  
16.     @SuppressWarnings("unchecked")  
17.     public static List<Comparable<?>> getSameList(List<Comparable<?>> list1, List<Comparable<?>> list2){  
18.         List<Comparable<?>> result = new ArrayList<Comparable<?>>();  
19.         //先转为数组排序  
20.         Object[] c1 = list1.toArray();   
21.         Object[] c2 = list2.toArray();  
22.         //O(nlog(n))  
23.         Arrays.sort(c1);  
24.         Arrays.sort(c2);  
25.         int len = c1.length;  
26.         //两个指针,当a>b时, 指向b的指针向后移;反正,当a<b时,指向a的指针向后移  
27.         int i=0,j=0;  
28.         //不会超过O(2n)  
29.         for(int k=0;k<len;k++){  
30.             Comparable a = (Comparable)c1[i];  
31.             Comparable b = (Comparable)c2[j];  
32.             if(a.compareTo(b)==0){  
33.                 i++;  
34.                 j++;  
35.                 result.add(a);  
36.             }  
37.             else if(a.compareTo(b)<0) {  
38.                 i++;  
39.             }else {  
40.                 j++;  
41.             }  
42.         }  
43.         //去掉重复的  
44.         return new ArrayList(new LinkedHashSet(result));  
45.     }  
46.       
47.     static Random random = new Random();  
48.     //获取随机字符串,长度1~5，由小写字母组成  
49.     private static String getRandomString(){  
50.         int len = random.nextInt(5)+1;  
51.         char[] chs = new char[len];  
52.         for(int i=0;i<len;i++){  
53.             chs[i]=(char)('a'+random.nextInt(26));  
54.         }  
55.         return new String(chs);  
56.     }  
57.       
58.     //打印列表  
59.     private static void printList(List<?> list){  
60.         if(list == null){  
61.             System.out.println("null");  
62.         }  
63.         for(Object object :list){  
64.             System.out.print(object+"\t");  
65.         }  
66.         System.out.println();  
67.     }  
68.       
69.     //生成由随机字符串组成的列表  
70.     private static List<Comparable<?>> generateRandomList(int len){  
71.         List<Comparable<?>> l1 = new ArrayList<Comparable<?>>();  
72.         for(int i=0;i<len;i++){  
73.             l1.add(getRandomString());  
74.         }  
75.         return l1;  
76.     }  
77.       
78.       
79.     //太大的不打印,写到文件自己查看吧  
80.     @SuppressWarnings("unchecked")  
81.     private static void writeListToTxt(List list,String path){  
82.         Object[] arr = list.toArray();  
83.         Arrays.sort(arr);  
84.         int len = arr.length;  
85.         StringBuilder sb = new StringBuilder(len);  
86.         for(int i=0; i<len;i++){  
87.             sb.append(arr[i]).append("\t");  
88.         }  
89.         File file = new File(path);  
90.         OutputStreamWriter writer = null;  
91.         try {  
92.             if(!file.exists()){  
93.                 file.createNewFile();  
94.             }  
95.             writer = new OutputStreamWriter(new FileOutputStream(file));  
96.             writer.write(sb.toString());  
97.         } catch (FileNotFoundException e) {  
98.             e.printStackTrace();  
99.         } catch (IOException e) {  
100.             e.printStackTrace();  
101.         }finally{  
102.             if(writer!=null){  
103.                 try {  
104.                     writer.close();  
105.                 } catch (IOException e) {  
106.                     e.printStackTrace();  
107.                 }  
108.             }  
109.         }  
110.     }  
111.     //超过1000行的就不打印了，大家随意  
112.     private static boolean isPrintable(int len){  
113.         return len<=1000;  
114.     }  
115.       
116.     @SuppressWarnings("unchecked")  
117.     public static void main(String[] args) {  
118.         int len = 100000;  
119.         List<Comparable<?>> l1 = generateRandomList(len);  
120.         List<Comparable<?>> l2 = generateRandomList(len);  
121.           
122.         if(isPrintable(len)){  
123.             System.out.println("the two list are here");  
124.             printList(l1);  
125.             printList(l2);  
126.         }  
127.           
128.         writeListToTxt(l1, "C:\\l1.txt");  
129.         writeListToTxt(l2, "C:\\l2.txt");  
130.           
131.           
132.           
133.         long start = System.currentTimeMillis();  
134.         List<Comparable<?>> sameList = getSameList(l1, l2);  
135.         long end = System.currentTimeMillis();  
136.         System.out.println("spends "+(end-start)+" ms to make it done. "  
137.                 +"\nthe sameList's size is "+sameList.size()  
138.                 +"\nand the sameList elements are:");  
139.         printList(sameList);  
140.         //写到文件  
141.         writeListToTxt(sameList, "C:\\same.txt");  
142.     }  
143. }