为了解决上传网盘时单文件大小限制，或向某某公司邮箱发送文件时的文件大小限制，我们常常需要将较大的文件拆分成多个在限制大小内的小文件，进行传输后，在使用端再将多个小文件合并为一个完整的大文件进行使用。
 
使用 zip 命令压缩文件
 
1.使用 zip 命令压缩文件，并结合 split 命令来分卷：
zip - <file_name> | split -b <max_size>
 上述命令将名为file_name的文件压缩成 zip 包并分成不超过max_size的文件，分解后文件名默认是 x* ，后缀为 2 位 a-z 字母，如 aa、ab。
 其中，split命令如下： 
 
split [-a] [-b] [-C] [-l] [要分割的文件名] [分割后的文件名前缀]
–version 显示版本信息
– 或者-l,指定每多少行切割一次，用于文本文件分割
-b 指定切割文件大小,单位 m 或 k
-C 与-b类似，但尽量维持每行完整性
-d 使用数字而不是字母作为后缀名
-a 指定后缀名的长度，默认为2位
 
例如：
 
#把 wm6.dmg 这个文件以 wm6.dmg. 开头，按1024m大小进行分割
split -b 1024m wm6.dmg wm6.dmg.
 
2.要合并已分解的文件，可使用cat命令恢复成 zip 文件后使用 unzip 或其它主流解压软件解压，命令如下：
cat <files_name_1> <files_name_2> <files_name_3> > <files_name>
 
意思是把files_name_1、2、3这三个文件进行合并，合并（创建）成一个叫files_name的文件；
 例如：
cat x* > file.zip
 
使用 tar 命令压缩文件
 
使用 tar 命令来创建压缩文件，如：
tar czvf - <file_name> | split -b <max_size>
使用 tar 解压：
cat x* | tar xzvf -
 

当前需求
 
 
 
每个文件压缩前最大为50M，超出文件限制指标在新文件中存储，新文件序号+1，序号从001开始最大为999，性能文件生成后采用gzip压缩存储。
 
 
分析
 
文件压缩、解压
文件拆分、合并
 
 
文件拆分、合并
 
生成测试文件
 
public class GenerateFileDemo {

	public static void main(String[] args) throws IOException {
		String path = CompressDemo.class.getResource("/").getPath();
		BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path + "big.data"));
		String str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1";
		for (int i = 0; i < 1000000; i++) {
			bufferedWriter.write(i + str);
			bufferedWriter.newLine();
		}
		bufferedWriter.flush();
		bufferedWriter.close();
	}
}
 
生成文件900多MB
 
 文件拆分
 
public class BigFileWriteDemo {
	// 1MB
	private static final int FILE_SIZE = 1 * 1024 * 1024;
	// 文件结束标识
	private static final int EOF = -1;

	public static void main(String[] args) throws IOException {
		
		String path = BigFileWriteDemo.class.getResource("/").getPath();
		System.out.println(path);
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path + "big.data"));
		int available = bis.available();
		System.out.println(available);
		
		System.out.println(String.format("%.2fMB", available * 1.0 / FILE_SIZE));
		
		// 拆分成每个为50Mb大小的文件
		int saveSize = 50 * FILE_SIZE;
		byte[] bytes = new byte[saveSize];
		
		int length = EOF;
		// 子文件下标
		int filenameExt = 1000;
		while ( (length = bis.read(bytes)) > EOF ) {
			try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(path + "sub-big-" + (filenameExt++) + ".data"));) {
				bos.write(bytes, 0, length);
			}
		}
		bis.close();
	}
}
 
生成子文件19个，其中18个大小为50MB
 
 
合并文件
 
public class BigFileReadDemo {

	// 1MB
	private static final int FILE_SIZE = 1 * 1024 * 1024;
	// 文件结束标识
	private static final int EOF = -1;

	public static void main(String[] args) throws IOException {
		
		String path = BigFileReadDemo.class.getResource("/").getPath();
		// 这里zzz为通用占位符、匹配拆分文件时下标数字
		String filename = "sub-big-zzz.data".replace("zzz", "\\d+");
		
		File file = new File(path);
		if (!file.isDirectory()) {
			return;
		}
		
		String name = file.getName();
		System.out.println(name);
		String[] list = file.list();
		Stream<String> stream = Arrays.stream(list);
		
		List<String> subFileNames = stream.filter(s->s.matches(filename))
				.sorted()
				.collect(Collectors.toList());
		
		if (subFileNames == null || subFileNames.size() < 1) {
			return ;
		}
		
		// 组装文件
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream(path + "composite-big.data"));
		for (String subFilename : subFileNames) {
			try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path + subFilename));) {
				int available = bis.available();
				System.out.println(available);
				// 每次读取1Mb大小的文件
				byte[] bytes = new byte[FILE_SIZE];
				int length = EOF;
				while ((length = bis.read(bytes)) > EOF) {
					bos.write(bytes, 0, length);
				}
				bos.flush();
			}
		}
		bos.close();
	}
}
 
合并结果，与原文件大小一直
 
 
文件压缩、解压
 
定义抽象接口
 
public interface Compress {
	/**
	 * 数据压缩
	 */
	byte[] compress(byte[] data) throws IOException;

	/**
	 * 数据解压
	 */
	byte[] uncompress(byte[] data) throws IOException;

}
 
抽象压缩解压算法
 
public abstract class AbstractCompress implements Compress {
	
	// 构建模板方法
	protected abstract OutputStream createOutputStream(OutputStream output) throws IOException;
	protected abstract InputStream createInputStream(InputStream input) throws IOException;
	
	@Override
	public byte[] compress(byte[] data) throws IOException {
		ByteArrayOutputStream os = new ByteArrayOutputStream();
		try (OutputStream cs = createOutputStream(os)) {
			cs.write(data);
		}
		return os.toByteArray();
	}

	@Override
	public byte[] uncompress(byte[] data) throws IOException {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] buffer = new byte[4096];
		int len = 0;
		
		try (InputStream us = createInputStream(new ByteArrayInputStream(data))) {
			while ((len = us.read(buffer)) != -1) {
				baos.write(buffer, 0, len);
			}
		}
		return baos.toByteArray();
	}
}
 
实现Gzip算法
 
/**
 * gzip算法
 * 
 * <p>继承关系,基于DeflaterOutputStream的包装</p>
 * <pre>
 * java.lang.Object
 *   java.io.OutputStream
 *     java.io.FilterOutputStream
 *       java.util.zip.DeflaterOutputStream
 *         java.util.zip.GZIPOutputStream
 * </pre>
 * 
 */
public class GzipCompress extends AbstractCompress {

	@Override
	protected OutputStream createOutputStream(OutputStream output) throws IOException {
		return new GZIPOutputStream(output);
	}

	@Override
	protected InputStream createInputStream(InputStream input) throws IOException {
		return new GZIPInputStream(input);
	}
}
 
编写工具类
 
public class CompressUtil {
	private static final Compress INSTANCE = new GzipCompress();
	
	private CompressUtil() {}
	
	public static byte[] compress(byte[] data) throws IOException {
		return INSTANCE.compress(data);
	}

	public static byte[] uncompress(byte[] data) throws IOException {
		return INSTANCE.uncompress(data);
	}
	
}
 
测试
 
压缩文件
 
public class CompressDemo {
	private static final String EXT = ".zip";

	public static void main(String[] args) throws IOException {
		
		String path = CompressDemo.class.getResource("/").getPath();
		System.out.println(path);
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path + "demo.json"));
		int available = bis.available();
		byte[] data = new byte[available];
		System.out.println(data.length);
		bis.read(data);
		byte[] compressData = CompressUtil.compress(data);
		System.out.println(compressData.length);
		
		// 保持压缩文件
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(path + "demo.json" + EXT));
		bos.write(compressData);
		
		bis.close();
		bos.close();
	}
}

 
压缩成功
 
 
解压文件
 
public class UnCompressDemo {
	
	private static final String EXT = ".zip";

	public static void main(String[] args) throws IOException {
		
		String path = UnCompressDemo.class.getResource("/").getPath();
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path + "demo.json" + EXT));
		int available = bis.available();
		byte[] data = new byte[available];
		System.out.println(data.length);
		bis.read(data);
		byte[] uncompressData = CompressUtil.uncompress(data);
		System.out.println(uncompressData.length);
		
		BufferedReader uncompressStream = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(uncompressData)));
		String line = null;
		while ( (line = uncompressStream.readLine()) != null ) {
			System.out.println(line);
		}
		bis.close();
		uncompressStream.close();
	}
}

 
输出原demo.json内容
 
剩下只需要组装功能即可完成上述需求，不再演示

Original url:
https://blog.csdn.net/xunan003/article/details/79068648

有没有遇到某些网站上传复件时，单个文件有大小限制，导致上传失败呢？当然你可以采用更高的压缩率重新生成压缩包来解决，但如果还是超出大小限制，那该怎么办呢？有个方法可以解决此类问题，将压缩包分成多个文件，问题就迎刃而解，这就叫：分卷压缩。
如何进行分卷压缩与解压呢，有如下几个命令可供使用：
假设当前目录下有proc目录。

tar -czf - proc | split -b 2m -d - proc.tar.gz #分卷压缩proc目录，并保持每个压缩包的大小不超过2m字节。命令执行后，会生成proc.tar.gz00、proc.tar.gz01等文件

cat proc.tar.gz* | tar -xzf - #将各个分卷压缩包解压到当前目录

cat proc.tar.gz* > proc.tar.gz #将各个分卷压缩包合成为一个proc.tar.gz文件

附录：split命令的使用
split proc.tar.gz -b 2m #将proc.tar.gz文件分割为多个小文件，并保持每个小文件的大小不超过2m字节。命令运行后，源文件依然存在。生成的小文件以默认格式命名，为：xaa、xab等
split proc.tar.gz -b 2m -d #基本同上，只是生成的小文件以数字格式命名，为：x00、x01等
split proc.tar.gz -b 2m -d proc.tar.gz #基本同上，只是生成的小文件名前缀是自定义的，为：proc.tar.gz00、proc.tar.gz01等

split a.txt -C 300k -d a.txt #将a.txt文本文件分割为多个小文件，并保持每个小文件的大小不超过300k字节，而且尽量保持每行的完整性




解压：
解压xxx.tar.gz00   xxx.tar.gz01   xxx.tar.gz02   xxx.tar.gz03   xxx.tar.gz04  ……先用以下命令合并
 cat xxx.tar.gz*  >>xxx.tar.gz
然后用tar  -vzxf  xxx.tar.gz解压

使用split命令拆分文件。
 
split -b 4000 -d -a 2 split_file split_file.
 
-b：以文件大小拆分，默认单位M，可以通过修改后数字以及换单位来自由选择拆分后文件大小，比如-b 200K
 
-l：以文件行数拆分
 
-d：拆分后的的文件命令以数字为后缀，split_file.00，split_file.01等等
 
-a：后缀的长度，默认为两位数，可以更改数字。
 
 
 
使用cat命令来还原拆分的文件。
 
cat split_file.* split_file