欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2023-12-11 22:08:40
复制代码 代码如下:package com.test;  import java.io.bufferedreader;  import java.i...

复制代码 代码如下:

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; 
     } 

上一篇:

下一篇: