用java实现大文件分割与合并

package com.test;

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 < CountNumbers; 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() < countAccuracy + 1 && ispass) {
	      temp = null;
	     } else {
	      temp = object;
	      break;
	     }
	    }
	    // 写入数据源
	    fs.write(object + "\r\n");
	    // 记录数据的下标
	    tempCount++;
	   }
	  } catch (IOException e) {
	   e.printStackTrace();
	  }
	  return temp;
	 }
}