1亿数据取前1w个数据不超过4秒的java 程序

[java]  view plain copy print ?

package net.test;     

1. import java.util.Arrays;  
2. import java.util.Date;  
3. import java.util.Random;  
4.   
5. public class Top100 {  
6.       
7.     public static void main(String[] args) {  
8.         find();  
9.     }  
10.     public static void find( ) {//  
11.         int number = 100000000;// 一亿个数  
12.         int maxnum = 1000000000;// 随机数最大值  
13.         int i = 0;  
14.         int topnum = 10000;// 取最大的多少个  
15.        
16.         Date startTime = new Date();  
17.           
18.         Random random = new Random();  
19.         int[] top = new int[topnum];  
20.         for (i = 0; i < topnum; i++) {  
21.             top[i] = Math.abs(random.nextInt(maxnum));//设置为随机数  
22. //          top[i] = getNum(i);  
23.         }  
24.   
25.         buildHeap(top, 0, top.length);// 构建最小堆， top[0]为最小元素  
26.         for (i = topnum; i < number; i++) {  
27.   
28.             int currentNumber2 = Math.abs(random.nextInt(maxnum));//设置为随机数  
29. //          int currentNumber2 = getNum(i);  
30.             // 大于 top[0]则交换currentNumber2  重构最小堆  
31.             if (top[0] < currentNumber2) {  
32.                 top[0] = currentNumber2;  
33.                 shift(top, 0, top.length, 0); // 构建最小堆 top[0]为最小元素  
34.             }  
35.         }  
36.         System.out.println(Arrays.toString(top));  
37.         sort(top);  
38.         System.out.println(Arrays.toString(top));  
39.           
40.         Date endTime = new Date();  
41.         System.out.println("用了"+(endTime.getTime() - startTime.getTime())+"毫秒");  
42.    
43.     }  
44.       
45.     public static int getNum(int i){  
46.         return i;  
47.     }  
48.   
49.    
50.     //构造排序数组  
51.     public static void buildHeap(int[] array, int from, int len) {  
52.         int pos = (len - 1) / 2;  
53.         for (int i = pos; i >= 0; i--) {  
54.             shift(array, from, len, i);  
55.         }  
56.     }  
57.    
58.     /** 
59.      * @param array top数组 
60.      * @param from 开始 
61.      * @param len 数组长度 
62.      * @param pos 当前节点index 
63.      * */  
64.     public static void shift(int[] array, int from, int len, int pos) {  
65.         // 保存该节点的值   
66.         int tmp = array[from + pos];  
67.   
68.         int index = pos * 2 + 1;// 得到当前pos节点的左节点  
69.         while (index < len)//  存在左节点  
70.         {  
71.             if (index + 1 < len  
72.                     && array[from + index] > array[from + index + 1])// 如果存在右节点  
73.             {  
74.                 // 如果右边节点比左边节点小，就和右边的比较  
75.                 index += 1;  
76.             }  
77.                
78.             if (tmp > array[from + index]) {  
79.                 array[from + pos] = array[from + index];  
80.                 pos = index;  
81.                 index = pos * 2 + 1;  
82.             } else {  
83.                 break;  
84.             }  
85.         }  
86.         // 最终全部置换完毕后 ，把临时变量赋给最后的节点  
87.         array[from + pos] = tmp;  
88.     }  
89.       
90.     public static void sort(int[] array){    
91.         for(int i = 0; i < array.length - 1; i++){    
92.             //当前值当作最小值    
93.             int min = array[i];    
94.             for(int j = i+1; j < array.length; j++){    
95.                 if(min>array[j]){    
96.                     //如果后面有比min值还小的就交换    
97.                     min = array[j];    
98.                     array[j] = array[i];    
99.                     array[i] = min;    
100.                 }    
101.             }    
102.         }    
103.     }  
104.   
105. }