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

}

}

时间： 2024-08-01 10:44:41

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

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

在平常的生活中,我们会遇到下面这样的情况: 你下载了一个比较大型的游戏(假设有10G),现在想跟你的同学一起玩,你需要把这个游戏拷贝给他. 然后现在有一个问题是文件太大(我们不考虑你有移动硬盘什么的情况),假设现在只有一个2G或4G的优盘,该怎么办呢? 有很多方法,例如winrar压缩的时候分成很多小卷,这里不累述. 在学习python之后,我们自己就可以解决这个问题啦. 我们可以自己写一个脚本去分割合并文件,将文件分割成适合优盘大小的小文件,在拷贝,然后再合并. 下面是文件分割脚本: 1 im

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

分割文件 /* * 分割文件 * 默认大小 2M=10485760/5 */ function file_split($file,$block_size=10485760/5) { $block_info=array(); $size=filesize($file); $i=0; while($size>0){ $block_info[]=array( 'size'=>($size>=$block_size?$block_size:$size), 'file'=>str_repla

java:快速文件分割及合并

文件分割与合并是一个常见需求,比如:上传大文件时,可以先分割成小块,传到服务器后,再进行合并.很多高大上的分布式文件系统(比如:google的GFS.taobao的TFS)里,也是按block为单位,对文件进行分割或合并. 看下基本思路: 如果有一个大文件,指定分割大小后(比如:按1M切割) step 1: 先根据原始文件大小.分割大小,算出最终分割的小文件数N step 2: 在磁盘上创建这N个小文件 step 3: 开多个线程(线程数=分割文件数),每个线程里,利用RandomAccessF

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

文件分割与合并是一个常见需求,比如:上传大文件时,可以先分割成小块,传到服务器后,再进行合并.很多高大上的分布式文件系统(比如:google的GFS.taobao的TFS)里,也是按block为单位,对文件进行分割或合并. 看下基本思路: 如果有一个大文件,指定分割大小后(比如:按1M切割) step 1: 先根据原始文件大小.分割大小,算出最终分割的小文件数N step 2: 在磁盘上创建这N个小文件 step 3: 开多个线程(线程数=分割文件数),每个线程里,利用RandomAccessF

java文件分割和合并

package search; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.RandomAccessFile; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class Split {

c语言文件分割与合并

一.综述 c语言操作文件通过文件指针FILE*,每个要操作的文件必须打开然后才能读写. 注意事项: @1分割与合并文件最好使用二进制模式即"rb"或"wb",这样可以操作任何类型文件 @2FILE 指针一定要进行判空操作即看F == NULL成立不 @3文件用完必须关闭,释放系统资源,因为文件会分配缓冲区,占据内存 1.包含头文件 _CRT_SECURE_NO_WARNINGS表示关闭安全检查 1 #define _CRT_SECURE_NO_WARNINGS 2

android下大文件分割上传

由于android自身的原因,对大文件(如影视频文件)的操作很容易造成OOM,即:Dalvik堆内存溢出,利用文件分割将大文件分割为小文件可以解决问题. 文件分割后分多次请求服务. 1 //文件分割上传 2 public void cutFileUpload(String fileType,String filePath) 3 { 4 try 5 { 6 FileAccessI fileAccessI = new FileAccessI(filePath, 0); 7 Long nStartPo

日志解析(四) 大文件分割

将百兆大文件分割成几十M的小文件,按大小进行分割 package com.fenge; import java.io.BufferedReader;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.FileReader;import java.io.IOException; public class fenge {    public static f

Linux命令之大文件切分与合并

当面临将一个大文件进行切分时,linux的split命令是很好的选择.它包含多种参数,支持按行.大小进行切分. split命令的语法如下: split [--help][--version][-a ][-b][-C ][-l ][要切割的文件][输出文件名前缀] 对应的参数描述如下: -a, --suffix-length=N 使用的后缀长度 (默认为 2) -b, --bytes=SIZE 每个输出文件的字节大小 -C, --line-bytes=SIZE 每个输出文件每行的最大字节大小 -d