大数据小内存排序

需求：有一个很大的文件需要对内容进行排序（ps:内容可简单理解为数字），如何在有限的内存下进行排序，内存很小。
分析：
1.文件很大我们需要分而治之，分为若干文件
2.内存小，划分小文件的时候要注意，文件内容应该可以足够放入内存
3.拆分小文件的时候，对改文件内容进行排序（ps:非本文章重点故省略）
4.对有序的文件进行归并排序

以上就是大致的思路，下面直接上代码，代码略有粗糙，各位看客包涵，同时希望您提出宝贵的建议

package a;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class SplitSort {
    private final static int SORT_BUF_LEN = 128;
    private final static int MAX_BUF_INDEX = SORT_BUF_LEN-1;
    private final static int FILE_COUNT = 8;

    public static void main(String[] args) {
        start();
//      createFile();
    }

    public static void start() {
        int[] sortbuf = new int[SORT_BUF_LEN];
        int curIndex = 0;
        BufferedReader[] read = new BufferedReader[FILE_COUNT];
        ArrayList<Sort> list = new ArrayList<Sort>();
        initFile(read);
        initSortList(read, list);
        curIndex = sort(sortbuf, curIndex, read, list);
    }

    private static int sort(int[] sortbuf, int curIndex, BufferedReader[] read,
            ArrayList<Sort> list) {
        while (true) {
            findMinAndReplace(sortbuf, curIndex, read, list);
            if (curIndex == MAX_BUF_INDEX) {
                curIndex = 0;
                System.out.println(Arrays.toString(sortbuf));
                if (list.size() < 1) {
                    break;
                }
            } else {
                curIndex++;
            }
        }
        return curIndex;
    }

    private static void initFile(BufferedReader[] read) {
        for (int i = 1; i < 9; i++) {
            File file = new File("d:\\" + i + ".txt");
            try {
                @SuppressWarnings("resource")
                BufferedReader bos = new BufferedReader(new FileReader(file));
                read[i - 1] = bos;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private static void initWriteFile(BufferedWriter[] writer) {
        for (int i = 1; i < 9; i++) {
            File file = new File("d:\\" + i + ".txt");
            try {
                @SuppressWarnings("resource")
                BufferedWriter bos = new BufferedWriter(new FileWriter(file));
                writer[i - 1] = bos;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void findMinAndReplace(int[] sortbuf, int sortcur,
            BufferedReader[] read, ArrayList<Sort> list) {
        Collections.sort(list);
        Sort sort = list.get(0);
        sortbuf[sortcur] = sort.value;
        try {
            String readLine = read[sort.index].readLine();
            if (readLine != null && readLine.trim() != "") {
                sort.value = Integer.parseInt(readLine);
            } else {
                list.remove(0);
                read[sort.index].close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void initSortList(BufferedReader[] read, ArrayList<Sort> list) {
        for (int i = 0; i < read.length; i++) {
            try {
                list.add(new Sort(i, Integer.parseInt(read[i].readLine())));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void createFile() {
        try {
            BufferedWriter[] writers = new BufferedWriter[FILE_COUNT];
            initWriteFile(writers);
            for (int i = 1; i < 1025; i++) {
                int index = i%8;
                writers[index].append(i + "\r\n");
            }
            for (BufferedWriter bufferedWriter : writers) {
                bufferedWriter.close();
            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private static class Sort implements Comparable<Sort> {
        int index;
        int value;

        public Sort(int i, int readLine) {
            this.index = i;
            this.value = readLine;
        }

        @Override
        public int compareTo(Sort o) {
            return this.value > o.value ? 1 : -1;
        }

    }
}