JAVA IO分析三：IO总结&文件分割与合并实例
时间飞逝，马上就要到2018年了，今天我们将要学习的是IO流学习的最后一节，即总结回顾前面所学，并学习一个案例用于前面所学的实际操作，下面我们就开始本节的学习：
一、原理与概念
一、概念
流:流动 、流向 从一端移动到另一端 源头与目的地
程序 与 文件|数组|网络连接|数据库 ，以程序为中心
二、IO流分类
1、流向: 输入流与输出流
2、数据:字节流:二进制，可以一切文件 包括 纯文本 doc 音频、视频等等
字符流:文本文件，只能处理纯文本
3、功能:节点:包裹源头
处理:增强功能，提供性能
三、字符流与字节流 （重点） 与文件
1、字节流
输入流:InputStream read(byte[] b) 、read(byte[] b, int off, int len) +close()
FileInputStream()
输出流:OutputStream write(byte[] b) write(byte[] b, int off, int len) +flush() +close()
FileOutputStream
2、字符流
输入流:Reader read(char[] cbuf) read(char[] cbuf, int off, int len) +close()
FileReader()
输出流:Writer write(char[] cbuf) write(char[] cbuf, int off, int len) +flush() +close()
write(String str, int off, int len)
FileWriter()
四、操作
1、举例:搬家 -->读取文件
1)、关联房子 --->建立与文件联系
2)、选择搬家 -->选择对应流
3)、搬家 -->读取|写出
a)、卡车大小 --->数组大小
b)、运输 -->读取、写出
4)、打发over -->释放资源
2、操作
1)建立联系
2)选择流
3)操作 数组大小+read 、write
4)释放资源
二、字节流
字节流:可以处理一切文件，包括二进制 音频、视频 、doc等
节点流: InputStream FileInputStream
OutputStream FileOutputStream
一、读取文件
1、建立联系 File对象 源头
2、选择流 文件输入流 InputStream FileInputStream
3、操作 : byte[] car =new byte[1024]; +read+读取大小
输出
4、释放资源 :关闭
二、写出文件
1、建立联系 File对象 目的地
2、选择流 文件输出流 OutputStream FileOutputStream
3、操作 : write() +flush
4、释放资源 :关闭
三、文件拷贝 程序为桥梁
1、建立联系 File对象 源头 目的地
2、选择流
文件输入流 InputStream FileInputStream
文件输出流 OutputStream FileOutputStream
3、操作 : 拷贝
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len=输入流.read(flush))){
输出流.write(flush,0,len)
}
输出流.flush
4、释放资源 :关闭 两个流
四、文件夹拷贝
1、递归查找子孙级文件|文件夹
2、文件 复制(IO流复制)
文件夹 创建
3、 A
/ \
a.txt b
|
b.txt
AA
|
A
/ \
a.txt b
|
b.txt
4、不能将父目录拷贝到子目录中
删除超长目录
三、字符流
字符流:只能处理 纯文本，全部为可见字符 .txt .html
节点流 Reader FileReader
Writer FileWriter
一、纯文本读取
1、建立联系
2、选择流 Reader FileReader
3、读取 char[] flush =new char[1024];
4、关闭
二、纯文本写出
1、建立联系
2、选择流 Writer FileWriter
3、读取 write(字符数组,0,长度)+flush
write(字符串)
append(字符|字符串)
4、关闭
四、处理流
处理流:增强功能、提供性能，节点流之上
一、缓冲流
1)、字节缓冲流
BufferedInputStream
BufferedOutputStream
2)、字符缓冲流
BufferedReader readLine()
BufferedWriter newLine()
二、转换流: 字节流 转为字符流 处理乱码(编码集、解码集)
1、编码与解码概念
编码： 字符 ---编码字符集>二进制
解码 : 二进制 --解码字符集-> 字符
2、乱码:
1)编码与解码的字符集不统一
2)字节缺少，长度丢失
3、文件乱码
InputStreamReader(字节输入流,"解码集")
OutputStreamWriter(字符输出流,"编码集")
五、其它流
一、节点流
1、字节数组 字节 节点流
输入流:ByteArrayInputStream read(byte[] b, int off, int len) + close()
输出流:ByteArrayOutputStream write(byte[] b, int off, int len) +toByteArray() 不要使用多态
二、处理流
1、基本类型+String 保留数据+类型
输入流:DataInputStream readXxx
输出流:DataOutputStream writeXxx
2、引用类型 (对象) 保留数据+类型
反序列化 输入流:ObjectInputStream readObject()
序列化 输出流:ObjectOutputStream writeObject()
注意:
1)、先序列化后反序列化；反序列化顺序必须与序列化一致
2)、不是所有的对象都可以序列化， java.io.Serializable
不是所有的属性都需要序列化，transient
3、打印流 PrintStream println() print()
4、三个常量 : System.in /out/err System.setIn() setOut() setErr()
六、小节
一、步骤： 创建源 选择流 操作(读取|写出) 释放
二、流
三、重点
四、操作
0、打印文件|目录
1、文件拷贝
2、关闭流方法
3、文件分割与合并(自学)
七、实例：文件分割与合并
目的：将文件分割成数个部分，然后再将它们合并起来
首先文件的分割，有下面几个要点
1.先要确定的两个因素就是，分成多少块，每块多大，那么最后一块的大小不一定刚好能是你规定的每小块的大小，那么最后一块的大小就比较特殊，它等于文件总大小（块数-1）乘以每块大小
2.在操作源文件到目的文件，即被分割文件到分割文件时，实际上就是文件的拷贝过程
3.最关键的问题是如何控制文件输入流，它必须按照指定的位置读取每一个分块
比如，我有142k大小的文件，要将他们分割成3块，规定每块大小为50，那么我将第一块内容读取的时候，是从0-50K
当读第二快内容时就变成了50-100K，那么如何控制读取范围？
这里就需要用到RandomAccessFile类，它提供了一个seek方法，可以指定读取的开始位置
文件的合并就是将那些分块重新组合在一起，比文件分割考虑的因素少，这里提供了两种不同的方式进行文件合并，其实也就是关于输入流做出的改变，详细见下文，合并从小块文件到大文件，其实也就是文件追加输出
本着OOP的设计思想，将对文件的信息和操作方法封装成一个类 SplitFile
这个类包含了关于文件的一些基本信息，文件的路径，大小，名称等，以及为了分割需要的一些信息，分割块数，每块的大小，分割文件所在的目录文件，各自的名称等，下面开始一步一步实现代码
1.类属性+构造方法
在构造方法运行结束后，初始化也结束，关于每块大小可以在创建对象的时候设置，也可以使用默认的1024
复制代码
public class SplitFile {
//文件路径
private String filePath;
//文件名称
private String fileName;
//文件大小
private long length;
//块数
private int size;
//每块大小
private long blockSize;
//每块名称
private List blockPath;
//分割后的目录
private String destPath;
public SplitFile() {
this.blockPath=new ArrayList();
}
public SplitFile(String filePath,String destPath){
this(filePath,1024,destPath);
}
public SplitFile(String filePath, long blockSize,String destPath) {
this();
this.filePath = filePath;
this.blockSize = blockSize;
this.destPath=destPath;
init();
}
}
复制代码
2.初始化分割信息
确定分割块数，先得到文件长度length
size=(int)(Math.ceil(length*1.0/this.blockSize));
确定部分文件的名称
由于将所有小文件的名称存放在List中，所以这里用一个for循环，往List中添加元素
其中destPath是存放部分文件的目录
for(int i=0;i=0){
bos.write(flush,0,len);
actualBlockSize-=len;
}else{
bos.write(flush,0,(int)actualBlockSize);
break;
}
}
文件的合并就比较简单了，第二种方法中用到了SequenceInputStream类，将很多个输入流集中在一起，只所有有很多个输入流是由于每一个部分文件对应一个输入流
要使用这个类就要先有一个集合，这里用Vector创建一个带泛型的Vector对象
使用for循环将文件输入流添加到容器中，然后构建SequenceInputStream对象
SequenceInputStream sis = new SequenceInputStream(vi.elements());
为了增强代码的健壮性，还添加了一些判断，下面是全部代码
复制代码
package com.bjsxt.io.others;
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.RandomAccessFile;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import com.bjsxt.io.util.FileUtil;
public class SplitFile {
//文件的路径
private String filePath;
//文件名
private String fileName;
//文件大小
private long length;
//块数
private int size;
//每块的大小
private long blockSize;
//分割后的存放目录
private String destBlockPath;
//每块的名称
private List blockPath;
public SplitFile(){
blockPath = new ArrayList();
}
public SplitFile(String filePath,String destBlockPath){
this(filePath,destBlockPath,1024);
}
public SplitFile(String filePath,String destBlockPath,long blockSize){
this();
this.filePath= filePath;
this.destBlockPath =destBlockPath;
this.blockSize=blockSize;
init();
}
/**
* 初始化操作 计算 块数、确定文件名
*/
public void init(){
File src =null;
//健壮性
if(null==filePath ||!(((src=new File(filePath)).exists()))){
return;
}
if(src.isDirectory()){
return ;
}
//文件名
this.fileName =src.getName();
//计算块数 实际大小 与每块大小
this.length = src.length();
//修正 每块大小
if(this.blockSize>length){
this.blockSize =length;
}
//确定块数
size= (int)(Math.ceil(length*1.0/this.blockSize));
//确定文件的路径
initPathName();
}
private void initPathName(){
for(int i=0;i=0){ //查看是否足够
//写出
bos.write(flush, 0, len);
actualBlockSize-=len; //剩余量
}else{ //写出最后一次的剩余量
bos.write(flush, 0, (int)actualBlockSize);
break;
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
FileUtil.close(bos,raf);
}
}
/**
* 文件的合并
*/
public void merge(String destPath){
//创建源
File dest =new File(destPath);
//选择流
BufferedOutputStream bos=null; //输出流
SequenceInputStream sis =null ;//输入流
//创建一个容器
Vector vi = new Vector();
try {
for (int i = 0; i < this.blockPath.size(); i++) {
vi.add(new BufferedInputStream(new FileInputStream(new File(this.blockPath.get(i)))));
}
bos =new BufferedOutputStream(new FileOutputStream(dest,true)); //追加
sis=new SequenceInputStream(vi.elements());
//缓冲区
byte[] flush = new byte[1024];
//接收长度
int len =0;
while(-1!=(len=sis.read(flush))){
bos.write(flush, 0, len);
}
bos.flush();
FileUtil.close(sis);
} catch (Exception e) {
}finally{
FileUtil.close(bos);
}
}
/**
* 文件的合并
*/
public void merge1(String destPath){
//创建源
File dest =new File(destPath);
//选择流
BufferedOutputStream bos=null; //输出流
try {
bos =new BufferedOutputStream(new FileOutputStream(dest,true)); //追加
BufferedInputStream bis = null;
for (int i = 0; i < this.blockPath.size(); i++) {
bis = new BufferedInputStream(new FileInputStream(new File(this.blockPath.get(i))));
//缓冲区
byte[] flush = new byte[1024];
//接收长度
int len =0;
while(-1!=(len=bis.read(flush))){
bos.write(flush, 0, len);
}
bos.flush();
FileUtil.close(bis);
}
} catch (Exception e) {
}finally{
FileUtil.close(bos);
}
}
/**
* @param args
*/
public static void main(String[] args) {
SplitFile split = new SplitFile("E:/xp/20130502/test/学员设置(20130502).xls","E:/xp/20130502",51);
//System.out.println(split.size);
//split.split();
split.merge("E:/xp/20130502/test1.xls");
}
}
复制代码
八、实例：思考如何多线程读取大文件？
参考:https://www.cnblogs.com/metoy/p/4470418.html
一、对文件分区
为了充分利用多线程读取，就需要把文件划分成多个区域，供每个线程读取。那么就需要有一个算法来计算出每个线程读取的开始位置和结束位置。那么首先根据配置的线程数和文件的总长度计，算出每个线程平均分配的读取长度。但是有一点，由于文件是纯文本文件，必须按行来处理，如果分割点在某一行中间，那么这一行数据就会被分成两部分，分别由两个线程同时处理，这种情况是不能出现的。所以各个区域的结束点上的字符必须是换行符。第一个区域的开始位置是0，结束位置首先设为（文件长度/线程数），如果结束点位置不是换行符，就只能加1，直到是换行符位置。第一个区域的结束位置有了，自然我们就能求出第二个区域的开始位置了，同理根据上边算法求出第二个区域的结束位置，然后依次类推第三个、第四个......
上边的算法中，第一个区域的结束位置定了，才能有第二个区域的开始位置，第二个区域的结束位置定了，才能有第三个区域的开始位置，依次这么下去。照这种规律，自然地想到的是用递归来解决。（详情看源码）
二、内存文件映射
简单说一下内存文件映射：
内存文件映射，简单地说就是将文件映射到内存的某个地址上。
要理解内存文件映射，首先得明白普通方式读取文件的流程：
首先内存空间分为内核空间和用户空间，在应用程序读取文件时，底层会发起系统调用，由系统调用将数据先读入到内核空间，然后再将数据拷贝到应用程序的用户空间供应用程序使用。这个过程多了一个从内核空间到用户空间拷贝的过程。
如果使用内存文件映射，文件会被映射到物理内存的某个地址上（不是数据加载到内存），此时应用程序读取文件的地址就是一个内存地址，而这个内存地址会被映射到了前面说到的物理内存的地址上。应用程序发起读之后，如果数据没有加载，系统调用就会负责把数据从文件加载到这块物理地址。应用程序便可以读取到文件的数据。省去了数据从内核空间到用户空间的拷贝过程。所以速度上也会有所提高。
读取大文件的实现中，就是用了Java的内存映射API，这样我们就可以在要读取某个地址时再将内容加载到内存。不需要一下子全部将内容加载进来。
源码样例如下：
复制代码
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel.MapMode;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
public class BigFileReader {
private int threadSize;
private String charset;
private int bufferSize;
private IHandle handle;
private ExecutorServic