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;  
         }  www.2cto.com
        }  
        // 写入数据源  
        fs.write(object + "\r\n");  
        // 记录数据的下标  
        tempCount++;  
       }  
      } catch (IOException e) {  
       e.printStackTrace();  
      }  
      return temp;  
     }  
}  

用java实现大文件分割、排序、合并的更多相关文章

  1. python学习——大文件分割与合并

    在平常的生活中,我们会遇到下面这样的情况: 你下载了一个比较大型的游戏(假设有10G),现在想跟你的同学一起玩,你需要把这个游戏拷贝给他. 然后现在有一个问题是文件太大(我们不考虑你有移动硬盘什么的情 ...

  2. python实现大文件分割与合并

    小U盘传大电影时可以免去用winrar分割文件时的压缩和解压缩过程. file.py import sys from os.path import exists fileCount = 0 def s ...

  3. Php处理大文件-分割和合并

    分割文件 /* * 分割文件 * 默认大小 2M=10485760/5 */ function file_split($file,$block_size=10485760/5) { $block_in ...

  4. java:快速文件分割及合并

    文件分割与合并是一个常见需求,比如:上传大文件时,可以先分割成小块,传到服务器后,再进行合并.很多高大上的分布式文件系统(比如:google的GFS.taobao的TFS)里,也是按block为单位, ...

  5. (转)java:快速文件分割及合并

    文件分割与合并是一个常见需求,比如:上传大文件时,可以先分割成小块,传到服务器后,再进行合并.很多高大上的分布式文件系统(比如:google的GFS.taobao的TFS)里,也是按block为单位, ...

  6. JAVA IO分析三:IO总结&文件分割与合并实例

    时间飞逝,马上就要到2018年了,今天我们将要学习的是IO流学习的最后一节,即总结回顾前面所学,并学习一个案例用于前面所学的实际操作,下面我们就开始本节的学习: 一.原理与概念 一.概念流:流动 .流 ...

  7. Linux中split大文件分割和cat合并文件

    当需要将较大的数据上传到服务器,或从服务器下载较大的日志文件时,往往会因为网络或其它原因而导致传输中断而不得不重新传输.这种情况下,可以先将大文件分割成小文件后分批传输,传完后再合并文件. 1.分割 ...

  8. android下大文件分割上传

    由于android自身的原因,对大文件(如影视频文件)的操作很容易造成OOM,即:Dalvik堆内存溢出,利用文件分割将大文件分割为小文件可以解决问题. 文件分割后分多次请求服务. //文件分割上传 ...

  9. c语言文件分割与合并

    一.综述 c语言操作文件通过文件指针FILE*,每个要操作的文件必须打开然后才能读写. 注意事项: @1分割与合并文件最好使用二进制模式即"rb"或"wb",这 ...

随机推荐

  1. Mac本地编辑服务器代码

    windows上映射网络驱动器可以直接在本地编辑远程服务器的代码,那么在mac上怎么配置呢? 1.打开finder——前往——连接服务器——输入:smb://********(你的机器名) 2.输入服 ...

  2. Bug跟踪的流程

    本文以翼发云协同项目管理系统为例子来讲解Bug跟踪的流程,它以工作流为中心的集成式Bug跟踪软件,它广泛地应用于研发行业的产品缺陷管理 与跟踪.事务跟踪.问题跟踪.任务跟踪.查询跟踪.需求管理.变更跟 ...

  3. es6 箭头函数(arrow function) 学习笔记

    箭头函数有两个好处. 1.他们比传统函数表达式简洁. const arr = [1, 2, 3]; const squares = arr.map(x => x * x); // 传统函数表达式 ...

  4. Linux下文件误删除恢复案例

    说明:将/etc/profile文件删除,然后恢复 在linux中为什么讲文件删除还能恢复呢? 详见:文件删除原理 http://blog.csdn.net/grantlee1988/article/ ...

  5. Windows 10 IoT Serials 8 – 如何改变UWP应用的目标平台

    Windows Insider计划直接加速了Windows系统的迭代,缩短了系统发布的周期.就Windows 10 IoT Core而言,迭代的速度和Windows 10 for PC.Windows ...

  6. 光环国际的PRINCE2培训是怎么上课的?

    一.面授班级: 基础级:3天知识精讲(含案例分享+现场演练) 上课时间:上午9:00-12:00,下午1:30-4:30分 考试时间:第3天课程结束后5:30-6:30分 1 个小时闭卷考试   专业 ...

  7. oracle习题1~13

    1. 查询Student表中的所有记录的Sname.Ssex和Class列. 2. 查询教师所有的单位即不重复的Depart列. 3. 查询Student表的所有记录. 4. 查询Score表中成绩在 ...

  8. Think In Java_读书笔记_042516

    面向对象程序设计方式: 1, 万物皆对象. 2,程序是对象的集合,他们通过发送消息来告知彼此所要做的.(个人理解,比如你调用方法的时候需要去调用某个对象的某个方法,必须传相应的参数,这些参数列表就相当 ...

  9. 重温Javascript(一)

    工作中要用到JavaScript,一组复习笔记. 一些看法 1. 想想JavaScript目前最常用的宿主环境,浏览器或者服务端V8,都是单线程,所以不用过多的考虑并发的问题,如果是协程来实现异步的方 ...

  10. POPTEST 150801 祝大家前途似锦

    POPTEST 150801 祝大家前途似锦   PT20150801学员不断在就业,同学们走好,远兵辛苦了!!!