一亿个数 top100

从一亿个数中找出最大的一百个数

随机生成一亿个0到一亿范围类的整数并输入到文件，从文件中读取这些输出其中最大的一百个数

随机生成一亿个数并存入文件

public class WriteFile {
    /**
     * 随机生成一亿个数并存入文件
     * @param filename 写入的文件的路径
     * @param length 生成随机数的个数
     */
    public static void writeFile(String filename,int length){
        File file=new File(filename);
        if(!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            FileWriter writer = new FileWriter(file);
            BufferedWriter out = new BufferedWriter(writer);
            Random random=new Random();
            for(int i=0;i<length;i++) {
                int num=random.nextInt(length);
                out.write(num+" ");
                if(i%50==0&&i!=0){
                    out.write("\n");
                }
                if(i%1000==0&&i!=0)
                    out.flush(); // 把缓存区内容压入文件
            }
            out.flush();
            out.close();
        } catch (IOException e) {
             e.printStackTrace();
        }
    }
}

从文件中读取并排序

使用桶排序的思想，统计每一个数的出现次数
使用byte数组来储存数组。byte在Java中占用一个字节，int占用4个字节，使用byte占用的空间只有使用int的四分之一；但是byte的最大值为127，所以当某一个数的出现次数大于127次后，将这个值储存在hashMap中。

public class ReadFile {
    /**
     * 从文件中读取文件并排序
     * @param filePath 需要读取的文件地址
     * @param array 保存读出的数字
     * @return 返回出现次数大于127次的数字<数字，出现次数>
     */
    public static HashMap<Integer,Integer> readFile(String filePath, byte[] array){
        HashMap<Integer,Integer> Record=new HashMap<>();//如果某个数的数量大于127，将这个数的数量存入Record中<当前数字，数字的数量>
        File file=new File(filePath);
        if(!file.exists()){
            System.out.println("文件不存在");
            return Record;
        }
        try {
            FileReader fileReader = new FileReader(file);
            BufferedReader reader = new BufferedReader(fileReader);
            String line = null;
            //读取文件和使用桶排序的排序过程
            while (null != (line = reader.readLine())) {
                String[] arStr = line.split(" ");
                for (String str : arStr) {
                    int num = Integer.parseInt(str.trim());
                    if (array[num] == 127) {
                        if (Record.containsKey(num)) {
                            Record.put(num, Record.get(num) + 1);
                        } else {
                            Record.put(num, 128);
                        }
                    } else {
                        array[num]++;
                    }
                }
            }
            reader.close();
            fileReader.close();
        }catch (IOException e) {
            e.printStackTrace();
        }
        return Record;
    }
}

输出最大的100个数

反向输出byte数组，例如byte[89]=10，将89这个数输出10次，如果byte[n]==127，从hashMap中读取出现次数。

public class Main {
    public  static final int num=100000000;
    public static final int topmin=100;

    public static void main(String[] args) {
        long startTime=System.currentTimeMillis();
//        WriteFile.writeFile("Number.txt",num);
        byte[] array=new byte[num];
        HashMap<Integer,Integer> Record=ReadFile.readFile("Number.txt",array);
        int count=0;//记录已经输出的数字的个数；
        for(int i=num-1;count<topmin;i--) {
            if(array[i]==0){
                continue;
            }else{
                int length=0;
                if(array[i]<127){
                    length=array[i];
                }else{
                    length=array[i];
                    if(Record.containsKey(i)){
                        length=Record.get(i);
                    }
                }
                for(int j=0;j<length;j++){
                    count++;
                    System.out.println(i);
                }
            }
        }
        long endTime=System.currentTimeMillis();
        System.out.println("项目运行时间为："+(endTime-startTime)+"ms");
    }
}