java实现大文件分割与合并的实例代码

import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.FileNotFoundException; 
import java.io.FileReader; 
import java.io.FileWriter; 
import java.io.IOException; 
import java.util.Collections; 
import java.util.Iterator; 
import java.util.LinkedList; 
import java.util.Random; 

public class LargeMappedFiles { 
    /**
      * 大数据排序合并
      * 
      * @param args
      */ 
     public static void main(String[] args) throws IOException { 
      // 写入文件的路径  
      String filePath = "D:\\456"; 
      // 切分文件的路径  
      String sqlitFilePath = "D:\\456\\123"; 
      //数据的个数  
      int CountNumbers=10000000; 

      //子文件的个数  
      int CountFile=10; 

      //精度  
      int countAccuracy=30*CountFile; 

      long startNumber=System.currentTimeMillis(); 
      // 写入大数据文件  
      WriteData(filePath,CountNumbers); 
      System.out.println("存储完毕"); 

      // 将大数据文件切分到另外的十个小文件中  
      sqlitFileDate(filePath, sqlitFilePath,CountFile); 
      System.out.println("文件切割完毕！"); 
      // 把每个文件的数据进行排序  
      singleFileDataSort(sqlitFilePath,CountFile); 
      System.out.println("每个子文件排序完毕！"); 

      //精度调整，十个文件数据进行比较整合  
      deathDataFile(filePath,sqlitFilePath,countAccuracy,CountFile); 
      System.out.println("整合完毕"); 
      long stopNumber=System.currentTimeMillis(); 
      System.out.println("耗时"+(stopNumber-startNumber)/1000+"毫秒"); 
     } 
     // 写入大数据文件  
     public static void WriteData(String path,int CountNumbers) throws IOException { 
      path = path + "\\12114.txt"; 
      FileWriter fs = new FileWriter(path); 
      BufferedWriter fw=new BufferedWriter(fs); 
      for (int i = 0; i        fw.write(new Random().nextInt(Integer.MAX_VALUE) + "\r\n"); 
      } 
      fw.close(); 
      fs.close(); 

     } 
     // 将大数据文件切分到另外的十个小文件中  
     public static void sqlitFileDate(String filepath, String sqlitPath, 
       int CountFile) throws IOException { 
      FileWriter fs = null; 
      BufferedWriter fw=null; 
      FileReader fr = new FileReader(filepath + "\\12114.txt"); 
      BufferedReader br = new BufferedReader(fr); // 读取获取整行数据  

      int i = 1; 
      LinkedList WriterLists=new LinkedList();    //初始化文件流对象集合  
      LinkedList fwLists=new LinkedList(); 
      for (int j = 1; j <= CountFile; j++) { 

        //声明对象  
        fs = new FileWriter(sqlitPath + "\\12" + j + ".txt",false); 
        fw=new BufferedWriter(fs); 

         
        //将对象装入集合  
        WriterLists.add(fs); 
        fwLists.add(fw); 
      } 
      //判断是文件流中是否还有数据返回  
      while (br.ready()) { 

       int count=1;//初始化第一文件流  
       for (Iterator iterator = fwLists.iterator(); iterator.hasNext();) { 
        BufferedWriter type = (BufferedWriter) iterator.next(); 
        if(i==count)//判断轮到第几个文件流写入数据了  
        { 
         //写入数据，跳出，进行下一个文件流，下一个数据的写入  
         type.write(br.readLine() + "\r\n"); 
         break; 
        } 
        count++; 
       } 
       //判断是否到了最后一个文件流了  
       if (i >= CountFile) { 
        i = 1; 
       } else 
        i++; 
      } 
      br.close(); 
      fr.close(); 
      for (Iterator iterator = fwLists.iterator(); iterator.hasNext();) { 
       BufferedWriter object = (BufferedWriter) iterator.next(); 
       object.close(); 
      } 
      //遍历关闭所有子文件流  
      for (Iterator iterator = WriterLists.iterator(); iterator.hasNext();) { 
       FileWriter object = (FileWriter) iterator.next(); 
       object.close(); 
      } 
     } 
     // 把每个文件的数据进行排序  
     public static void singleFileDataSort(String path1,int CountFile) throws IOException { 
      LinkedList nums = null; 
      for (int i = 1; i <= CountFile; i++) { 
       nums = new LinkedList(); 
       String path = path1 + "\\12" + i + ".txt"; 
       try { 
        FileReader fr = new FileReader(path); 
        BufferedReader br = new BufferedReader(fr); 
        while (br.ready()) { 
         // 将读取的单个数据加入到集合里面  
         nums.add(Integer.parseInt(br.readLine())); 
        } 
        // 对集合进行排序  
        Collections.sort(nums); 
        // 将排序好的数据写入源文件  
        numberSort(nums, path); 
        br.close(); 
        fr.close(); 
       } catch (NumberFormatException e) { 
        e.printStackTrace(); 
       } catch (FileNotFoundException e) { 
        e.printStackTrace(); 
       } catch (IOException e) { 
        e.printStackTrace(); 
       } 
      } 
     } 
     // 对每个文件数据进行排序，再写入源文件  
     public static void numberSort(LinkedList list, String path) { 
      try { 
       FileWriter fs = new FileWriter(path); 
       BufferedWriter fw=new BufferedWriter(fs); 
       for (Iterator iterator = list.iterator(); iterator.hasNext();) { 
        Object object = (Object) iterator.next(); 
        fw.write(object + "\r\n"); 
       } 
       fw.close(); 
       fs.close(); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
     } 
     // 文件数据最终整合(精度调整)  
     public static void deathDataFile(String filepath, String sqlitFilePath1, 
       int countAccuracy, int CountFile) throws IOException { 
      LinkedList nums = new LinkedList();                                       //添加数据，进行排序  
      Object temp = null;                                                       // 记录每次排序剩下的最后一个数字  
      boolean ispass = false; 
      LinkedList ispasses = null;                                               //记录数据文件的状态信息  
      FileWriter fs = new FileWriter(filepath + "\\Sort.txt", false);           //创建文件流，以便整合的数据写入  
      BufferedWriter bw=new BufferedWriter(fs); 
      FileReader fr = null;                                                     //声明读取文件流  
      BufferedReader br = null;                                                 //声明BufferedReader  
      LinkedList WriterLists = new LinkedList(); // 初始化文件流对象集合  
      LinkedList WriterListFile = new LinkedList(); 
      for (int j = 1; j <= CountFile; j++) { 
       // 声明对象，开启所有子文件流访问所有子文件的数据  
       fr = new FileReader(sqlitFilePath1 + "\\12" + j + ".txt"); 

       //开启所有BufferedReader，方便下次的整行的读取  
       br = new BufferedReader(fr); 

       // 将所有 FileReader对象装入集合  
       WriterListFile.add(fr); 

       // 将所有 BufferedReader对象装入集合  
       WriterLists.add(br); 
      } 
      for (;;) { 
       // 将十个源文件的是否有数据情况存入集合，以方便后面做判断  
       ispasses = new LinkedList(); 

       // 分别读取十个源文件的单个数据  
       for (Iterator iterator = WriterLists.iterator(); iterator.hasNext();) { 
        BufferedReader object = (BufferedReader) iterator.next(); 
        Object obj = null; 
        while (object.ready()) { 
         //添加所有文件流的每次的数据  
         nums.add(Integer.parseInt(object.readLine().toString())); 
         break; 
        } 
        if (object.ready() == false) 
         ispasses.add("true");           //将各文件中的数据状态存入集合中  
       } 

       // 决断是否是第一次进来  
       if (nums.size() % countAccuracy == 0 && ispass == false) { 
        // 对集合进行排序  
        Collections.sort(nums); 
        // 接收最大的数据，其它的数据写入总排序文件  
        temp = numberSortData(nums, filepath, false, countAccuracy, bw); 

        //重新初始化集合  
        nums = new LinkedList(); 
        // 添加上一组比较剩下的数据  
        nums.add(temp); 
        ispass = true; 
        // 记录源文件的数据数量，以便下次的遍历  
        continue; 
       } 
       if (ispass) { 
        if (nums.size() % countAccuracy == 1 && nums.size() > 1) { 
         // 对集合进行排序  
         Collections.sort(nums); 
         // 接收最大的数据，其它的数据写入总排序文件  
         temp = numberSortData(nums, filepath, true, countAccuracy, 
           bw); 
         nums = new LinkedList(); 
         nums.add(temp); 
         continue; 
        } 
       } 
       // 记录下一组数据的位置  
       // 判断是不是十个文件都没有数据  
       if (ispasses.size() == CountFile) { 
        Collections.sort(nums); 
        temp = numberSortData(nums, filepath, true, countAccuracy, bw); 
        nums = new LinkedList(); 
        break; 
       } 
      } 
      bw.close(); 
      //关闭写入流  
      fs.close(); 

      //关闭所有的BufferedReader  
      for (Iterator iterator = WriterLists.iterator(); iterator.hasNext();) { 
       BufferedReader object2 = (BufferedReader) iterator.next(); 
       object2.close(); 
      } 

      //关闭所有的FileReader  
      for (Iterator iterator = WriterListFile.iterator(); iterator.hasNext();) { 
       FileReader object = (FileReader) iterator.next(); 
       object.close(); 
      } 
     } 
     // 对数据进行排序,写入最终文件中(精度调整)  
     public static Object numberSortData(LinkedList list, String filePath, 
       boolean ispass, int countAccuracy,BufferedWriter fs) { 
      Object temp = 0;                                                        //记录最后一个值  
      int tempCount = 0;                                                      //记录写入的数据位置  
      try { 
       for (Iterator iterator = list.iterator(); iterator.hasNext();) { 
        Object object = (Object) iterator.next(); 
        // 判断是否是最后一个数  
        if (tempCount == list.size() - 1) { 
         // 判断集合里面不足一百個數了  
         if (list.size()           temp = null; 
         } else { 
          temp = object; 
          break; 
         } 
        } 
        // 写入数据源  
        fs.write(object + "\r\n"); 
        // 记录数据的下标  
        tempCount++; 
       } 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
      return temp; 
     } 
}