10.2.11 文件分割 文件合并 序列流

原创 于 2020-05-23 16:05:49 发布 · 136 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文详细介绍了Java中RandomAccessFile类的使用方法，包括随机读取、分段读取和分块处理。通过多个代码示例展示了如何对文件进行随机访问，以及如何将文件按指定大小分割成多个部分，最后提供了封装的类实现文件的自动分割与合并。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

RandomAcessFile：该类的实例支持读取和写入随机访问文件。随机访问文件的行为类似于存储在文件系统中的大量字节。
下面这段代码为随机读取，并且指定了读取位置，读取剩余所有内容：

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 随机读取和写入流 RandomAccessFile
 * @author 韩文韬
 *
 */
public class RandTest01 {
	public static void main(String[] args) throws IOException {
		RandomAccessFile raf=new RandomAccessFile(new File("src/com/sxt/io/copy.java"),"r");
		//随机读取 指定了起始位置，读取剩余所有内容
		raf.seek(2);
		//读取
		byte[] flush=new byte[1024];
		int len=-1;
		while((len=raf.read(flush))!=-1) {
			System.out.println(new String(flush,0,len));
		}
		raf.close();
	}
}

第二段代码体现了分段读取的思想：

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 随机读取和写入流 RandomAccessFile
 * @author 韩文韬
 *
 */
public class RandTest02 {
	public static void main(String[] args) throws IOException {
		RandomAccessFile raf=new RandomAccessFile(new File("src/com/sxt/io/copy.java"),"r");
		//起始位置
		int beginPos=2;
		//实际大小
		int actualSize=1026;
		//随机读取 指定了起始位置，分开思想：起始、实际大小
		raf.seek(beginPos);
		//读取
		byte[] flush=new byte[1024];
		int len=-1;
		while((len=raf.read(flush))!=-1) {
			if(actualSize>len) {
				System.out.println(new String(flush,0,len));
				actualSize-=len;
			}else {
				System.out.println(new String(flush,0,actualSize));
				break;
			}
		}
		raf.close();
	}
}

第三段代码为主函数怎么分块！

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 随机读取和写入流 RandomAccessFile
 * @author 韩文韬
 *
 */
public class RandTest03 {
	public static void main(String[] args) throws IOException {
		//分多少块
		File src=new File("src/com/sxt/io/copy.java");
		//总长度
		long len=src.length();
		//每块大小
		int blockSize=1024;
		//快数：多少块
		int size=(int)Math.ceil(len*1.0/blockSize);  //向上取整
		System.out.println(size);
	}
}

输出结果为：2 表示可以分两块
第四块代码为分块的改进，利用for循环输出分块

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 随机读取和写入流 RandomAccessFile
 * @author 韩文韬
 *
 */
public class RandTest04 {
	public static void main(String[] args) throws IOException {
		//分多少块
		File src=new File("src/com/sxt/io/copy.java");
		//总长度
		long len=src.length();
		//每块大小
		int blockSize=1024;
		//快数：多少块
		int size=(int)Math.ceil(len*1.0/blockSize);  //向上取整
		System.out.println(size);
		//思考每一块从哪里开始，从哪里结束
		//起始位置和实际大小
		int beginPos=0;
		int actualSize=(int)(blockSize>len?len:blockSize);
		for(int i=0;i<size;i++)
		{
			beginPos=i*blockSize;
			if(i==size-1) {//最后一块
				actualSize=(int)len;
			}else {
				actualSize=blockSize;
				len-=actualSize;
			}
			System.out.println(i+"-->"+beginPos+"-->"+actualSize);
		}
	}
}

输出结果为：
2
0–>0–>1024
1–>1024–>440 将分块表示的更加直观
第五块代码将前面的代码合起来，组成完整的代码：

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 随机读取和写入流 RandomAccessFile
 * @author 韩文韬
 *
 */
public class RandTest05 {
	public static void main(String[] args) throws IOException {
		//分多少块
		File src=new File("src/com/sxt/io/copy.java");
		//总长度
		long len=src.length();
		//每块大小
		int blockSize=1024;
		//快数：多少块
		int size=(int)Math.ceil(len*1.0/blockSize);  //向上取整
		System.out.println(size);
		//思考每一块从哪里开始，从哪里结束
		//起始位置和实际大小
		int beginPos=0;
		int actualSize=(int)(blockSize>len?len:blockSize);
		for(int i=0;i<size;i++)
		{
			beginPos=i*blockSize;
			if(i==size-1) {//最后一块
				actualSize=(int)len;
			}else {
				actualSize=blockSize;
				len-=actualSize;
			}
			System.out.println(i+"-->"+beginPos+"-->"+actualSize);
			split(i,beginPos,actualSize);
		}
	}
	/**
	 * 指定第i块的起始位置和实际长度
	 * @param i
	 * @param beginPos
	 * @param actualSize
	 */
	public static void split(int i,int beginPos,int actualSize) throws IOException{
		RandomAccessFile raf=new RandomAccessFile(new File("src/com/sxt/io/copy.java"),"r");
		//起始位置
		//实际大小
		//随机读取 指定了起始位置，分开思想：起始、实际大小
		raf.seek(beginPos);
		//读取
		byte[] flush=new byte[1024];
		int len=-1;
		while((len=raf.read(flush))!=-1) {
			if(actualSize>len) {
				System.out.println(new String(flush,0,len));
				actualSize-=len;
			}else {
				System.out.println(new String(flush,0,actualSize));
				break;
			}
		}
		raf.close();
	}
}

这样不但分了块，还输出了每一个分块的内容；
下面我们用代码来把它切开并且存储为一个一个的小文件，下面是完整代码：

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 随机读取和写入流 RandomAccessFile
 * @author 韩文韬
 *
 */
public class RandTest06 {
	public static void main(String[] args) throws IOException {
		//分多少块
		File src=new File("src/com/sxt/io/copy.java");
		//总长度
		long len=src.length();
		//每块大小
		int blockSize=1024;
		//快数：多少块
		int size=(int)Math.ceil(len*1.0/blockSize);  //向上取整
		System.out.println(size);
		//思考每一块从哪里开始，从哪里结束
		//起始位置和实际大小
		int beginPos=0;
		int actualSize=(int)(blockSize>len?len:blockSize);
		for(int i=0;i<size;i++)
		{
			beginPos=i*blockSize;
			if(i==size-1) {//最后一块
				actualSize=(int)len;
			}else {
				actualSize=blockSize;
				len-=actualSize;
			}
			System.out.println(i+"-->"+beginPos+"-->"+actualSize);
			split(i,beginPos,actualSize);
		}
	}
	/**
	 * 指定第i块的起始位置和实际长度
	 * @param i
	 * @param beginPos
	 * @param actualSize
	 */
	public static void split(int i,int beginPos,int actualSize) throws IOException{
		RandomAccessFile raf=new RandomAccessFile(new File("src/com/sxt/io/copy.java"),"r");
		RandomAccessFile raf2=new RandomAccessFile(new File("dest/"+i+"copy.java"),"rw");
		//起始位置
		//实际大小
		//随机读取 指定了起始位置，分开思想：起始、实际大小
		raf.seek(beginPos);
		//读取
		byte[] flush=new byte[1024];
		int len=-1;
		while((len=raf.read(flush))!=-1) {
			if(actualSize>len) {
				raf2.write(flush,0,len);
				actualSize-=len;
			}else {
				raf2.write(flush,0,actualSize);
				break;
			}
		}
		raf2.close();
		raf.close();
	}
}

运行后可以发现文件夹里面多了两个文件
在这里插入图片描述
当切分图片时：

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 随机读取和写入流 RandomAccessFile
 * @author 韩文韬
 *
 */
public class RandTest07 {
	public static void main(String[] args) throws IOException {
		//分多少块
		File src=new File("p.png");
		//总长度
		long len=src.length();
		//每块大小
		int blockSize=1024;
		//快数：多少块
		int size=(int)Math.ceil(len*1.0/blockSize);  //向上取整
		System.out.println(size);
		//思考每一块从哪里开始，从哪里结束
		//起始位置和实际大小
		int beginPos=0;
		int actualSize=(int)(blockSize>len?len:blockSize);
		for(int i=0;i<size;i++)
		{
			beginPos=i*blockSize;
			if(i==size-1) {//最后一块
				actualSize=(int)len;
			}else {
				actualSize=blockSize;
				len-=actualSize;
			}
			System.out.println(i+"-->"+beginPos+"-->"+actualSize);
			split(i,beginPos,actualSize);
		}
	}
	/**
	 * 指定第i块的起始位置和实际长度
	 * @param i
	 * @param beginPos
	 * @param actualSize
	 */
	public static void split(int i,int beginPos,int actualSize) throws IOException{
		RandomAccessFile raf=new RandomAccessFile(new File("p.png"),"r");
		RandomAccessFile raf2=new RandomAccessFile(new File("pic/"+i+"p.png"),"rw");
		//起始位置
		//实际大小
		//随机读取 指定了起始位置，分开思想：起始、实际大小
		raf.seek(beginPos);
		//读取
		byte[] flush=new byte[1024];
		int len=-1;
		while((len=raf.read(flush))!=-1) {
			if(actualSize>len) {
				raf2.write(flush,0,len);
				actualSize-=len;
			}else {
				raf2.write(flush,0,actualSize);
				break;
			}
		}
		raf2.close();
		raf.close();
	}
}

在这里插入图片描述
可以看到图片被分成一块一块的了；
下面我们来完成封装的工作：

package com.sxt.io;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.List;

/**
 * 面向对象思想封装 分割
 * @author 韩文韬
 *
 */
public class SplitFile {
	//源头
	private File src;
	//目的地（文件夹）
	private String destDir;
	//所有分割后的文件存储路径
	private List<String> destPaths;
	//每块大小
	private int blockSize;
	//块数：多少块
	private int size;
	
	public SplitFile(String srcPath, String destDir, int blockSize) {
		this.src = new File(srcPath);
		this.destDir = destDir;
		this.blockSize = blockSize;
		this.destPaths=new ArrayList<String>();
		//初始化
		init();
	}
	//初始化
	private void init() {
		//总长度
		long len=this.src.length();
		//块数；多少块
		this.size=(int)Math.ceil(len*1.0/blockSize);
		//路径
		for(int i=0;i<size;i++) {
			this.destPaths.add(this.destDir+"/"+i+"-"+this.src.getName());
		}
	}
	
	/**
	 * 分割
	 * 1 计算每一块的起始位置及大小
	 * 2 分割
	 * @param args
	 * @throws IOException
	 */
	public void split() throws IOException{
		//总长度
		long len=src.length();
		//起始位置和实际大小
		int beginPos=0;
		int actualSize=(int)(blockSize>len?len:blockSize);
		for(int i=0;i<size;i++) {
			beginPos=i*blockSize;
			if(i==size-1) {//最后一块
				actualSize=(int)len;
			}else {
				actualSize=blockSize;
				len-=actualSize;  //剩余量
			}
			splitDetail(i,beginPos,actualSize);
		}
	}
	
	
	/**
	 * 指定第i块的起始位置和实际长度
	 * @param i
	 * @param beginPos
	 * @param actualSize
	 */
	public void splitDetail(int i,int beginPos,int actualSize) throws IOException{
		RandomAccessFile raf=new RandomAccessFile(this.src,"r");
		RandomAccessFile raf2=new RandomAccessFile(this.destPaths.get(i),"rw");
		//随机读取 指定了起始位置，分开思想：起始、实际大小
		raf.seek(beginPos);
		//读取
		byte[] flush=new byte[1024];
		int len=-1;
		while((len=raf.read(flush))!=-1) {
			if(actualSize>len) {
				raf2.write(flush,0,len);
				actualSize-=len;
			}else {
				raf2.write(flush,0,actualSize);
				break;
			}
		}
		raf2.close();
		raf.close();
	}
	public static void main(String[] args) throws IOException {
		SplitFile sf=new SplitFile("src/com/sxt/io/RandTest08.java","dest",1024);
		sf.split();
	}
}

下面我们快速的将分割的文件合并：

package com.sxt.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.List;

/**
 * 面向对象思想封装 分割
 * @author 韩文韬
 *
 */
public class SplitFile02 {
	//源头
	private File src;
	//目的地（文件夹）
	private String destDir;
	//所有分割后的文件存储路径
	private List<String> destPaths;
	//每块大小
	private int blockSize;
	//块数：多少块
	private int size;
	
	public SplitFile02(String srcPath, String destDir, int blockSize) {
		this.src = new File(srcPath);
		this.destDir = destDir;
		this.blockSize = blockSize;
		this.destPaths=new ArrayList<String>();
		//初始化
		init();
	}
	//初始化
	private void init() {
		//总长度
		long len=this.src.length();
		//块数；多少块
		this.size=(int)Math.ceil(len*1.0/blockSize);
		//路径
		for(int i=0;i<size;i++) {
			this.destPaths.add(this.destDir+"/"+i+"-"+this.src.getName());
		}
	}
	
	/**
	 * 分割
	 * 1 计算每一块的起始位置及大小
	 * 2 分割
	 * @param args
	 * @throws IOException
	 */
	public void split() throws IOException{
		//总长度
		long len=src.length();
		//起始位置和实际大小
		int beginPos=0;
		int actualSize=(int)(blockSize>len?len:blockSize);
		for(int i=0;i<size;i++) {
			beginPos=i*blockSize;
			if(i==size-1) {//最后一块
				actualSize=(int)len;
			}else {
				actualSize=blockSize;
				len-=actualSize;  //剩余量
			}
			splitDetail(i,beginPos,actualSize);
		}
	}
	
	
	/**
	 * 指定第i块的起始位置和实际长度
	 * @param i
	 * @param beginPos
	 * @param actualSize
	 */
	public void splitDetail(int i,int beginPos,int actualSize) throws IOException{
		RandomAccessFile raf=new RandomAccessFile(this.src,"r");
		RandomAccessFile raf2=new RandomAccessFile(this.destPaths.get(i),"rw");
		//随机读取 指定了起始位置，分开思想：起始、实际大小
		raf.seek(beginPos);
		//读取
		byte[] flush=new byte[1024];
		int len=-1;
		while((len=raf.read(flush))!=-1) {
			if(actualSize>len) {
				raf2.write(flush,0,len);
				actualSize-=len;
			}else {
				raf2.write(flush,0,actualSize);
				break;
			}
		}
		raf2.close();
		raf.close();
	}
	/**
	 * 文件的合并
	 * @throws IOException 
	 */
	public void merge(String destPath) throws IOException {
		//输出流
		OutputStream os=new BufferedOutputStream(new FileOutputStream(destPath,true));
		//输入流
		for(int i=0;i<destPaths.size();i++) {
			InputStream is=new BufferedInputStream(new FileInputStream(src));
			//拷贝
			byte[] flush=new byte[1024];
			int len=-1;
			while((len=is.read(flush))!=-1) {
				os.write(flush, 0, len);
			}
			os.flush();
			is.close();
			
		}
		os.close();
		
	}
	public static void main(String[] args) throws IOException {
		SplitFile02 sf=new SplitFile02("src/com/sxt/io/SplitFile02.java","dest",1024);
		sf.split();
		sf.merge("aaa.java");
	}
}

输出结果：
在这里插入图片描述
可见分割并且合并成功；
下面我们使用SequenceInputStream来写一段代码：
首先打开API
A SequenceInputStream表示其他输入流的逻辑级联，它从一个有序的输入流集合开始，从第一个读取到文件的结尾，然后从第二个文件读取，依次类推，直到最后一个输入流达到文件的结尾
下面代码是其具体应用，可以达到与上文同样的效果！

package com.sxt.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

/**
 * 面向对象思想封装 分割
 * @author 韩文韬
 *
 */
public class SplitFile03 {
	//源头
	private File src;
	//目的地（文件夹）
	private String destDir;
	//所有分割后的文件存储路径
	private List<String> destPaths;
	//每块大小
	private int blockSize;
	//块数：多少块
	private int size;
	
	public SplitFile03(String srcPath, String destDir, int blockSize) {
		this.src = new File(srcPath);
		this.destDir = destDir;
		this.blockSize = blockSize;
		this.destPaths=new ArrayList<String>();
		//初始化
		init();
	}
	//初始化
	private void init() {
		//总长度
		long len=this.src.length();
		//块数；多少块
		this.size=(int)Math.ceil(len*1.0/blockSize);
		//路径
		for(int i=0;i<size;i++) {
			this.destPaths.add(this.destDir+"/"+i+"-"+this.src.getName());
		}
	}
	
	/**
	 * 分割
	 * 1 计算每一块的起始位置及大小
	 * 2 分割
	 * @param args
	 * @throws IOException
	 */
	public void split() throws IOException{
		//总长度
		long len=src.length();
		//起始位置和实际大小
		int beginPos=0;
		int actualSize=(int)(blockSize>len?len:blockSize);
		for(int i=0;i<size;i++) {
			beginPos=i*blockSize;
			if(i==size-1) {//最后一块
				actualSize=(int)len;
			}else {
				actualSize=blockSize;
				len-=actualSize;  //剩余量
			}
			splitDetail(i,beginPos,actualSize);
		}
	}
	
	
	/**
	 * 指定第i块的起始位置和实际长度
	 * @param i
	 * @param beginPos
	 * @param actualSize
	 */
	public void splitDetail(int i,int beginPos,int actualSize) throws IOException{
		RandomAccessFile raf=new RandomAccessFile(this.src,"r");
		RandomAccessFile raf2=new RandomAccessFile(this.destPaths.get(i),"rw");
		//随机读取 指定了起始位置，分开思想：起始、实际大小
		raf.seek(beginPos);
		//读取
		byte[] flush=new byte[1024];
		int len=-1;
		while((len=raf.read(flush))!=-1) {
			if(actualSize>len) {
				raf2.write(flush,0,len);
				actualSize-=len;
			}else {
				raf2.write(flush,0,actualSize);
				break;
			}
		}
		raf2.close();
		raf.close();
	}
	/**
	 * 文件的合并
	 * @throws IOException 
	 */
	public void merge(String destPath) throws IOException {
		//输出流
		OutputStream os=new BufferedOutputStream(new FileOutputStream(destPath,true));
		Vector<InputStream> vi=new Vector<InputStream>();
		SequenceInputStream sis=null;
		//输入流
		for(int i=0;i<destPaths.size();i++) {
			vi.add(new BufferedInputStream(new FileInputStream(destPaths.get(i))));
		}
		sis=new SequenceInputStream(vi.elements());
		//拷贝
		byte[] flush=new byte[1024];
		int len=-1;
		while((len=sis.read(flush))!=-1) {
			os.write(flush, 0, len);
		}
		os.flush();
		sis.close();
		os.close();
		
	}
	public static void main(String[] args) throws IOException {
		SplitFile03 sf=new SplitFile03("src/com/sxt/io/SplitFile02.java","dest",1024);
		sf.split();
		sf.merge("aaa.java");
	}
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值