0. 在进入正题之前回顾以下文件类File的基础：
java.io.File类定义了对文件的操作，比如：文件的创建、删除等
public File(String pathName):构造方法，创建文件句柄，包含完整的文件操作路径；
public File(File parent,String child):构造方法，创建文件句柄，设置父路径与子文件路径；
public boolean createNewFile() throws IOException :创建新文件；
public boolean exists( ) :判断给定的路径是否存在；
public boolean delete( ): 删除指定路径的文件
public File getParentFile():取得当前路径的父路径；
public boolean mkdirs():创建多级路径；
public long length():以字节为单位，获取文件的大小；
public boolean isFile():判断给定的路径是否是文件；
public boolean isDirectory():判断给定的路径是否是目录；
public long lastModified():取得文件最后一次修改的时间日期；
public String[ ] list():列出指定目录中的全部内容；
public File[ ] listFiles():列出所有的路径，以File类对象包装它们；
1. InputStream 字节输入流:从文件或网络中将数据读入缓存（数组等）中
java.io.InputStream和java.io.OutputStream 是一个抽象类,所以要进行文件的读取和写入一定要通过子类（FileInputStream、FileOutputStream）向上转型来进行抽象类对象的实例化操作。
InputStream 的常用方法：
InputStream是个抽象类，需要通过FileInputStream子类向上转型完成实例化：
InputStream inputStream=new FileInputStream(file);
子类的构造方法：FileInputStream(File file):设置要读取文件数据的路径。
从流中读取数据：
int read( ); //读取单个字节，返回值为所读的字节内容，如果已经没有内容要读取了则返回-1。
int read( byte b[ ] ); //读取多个字节，将数据读取到字节数组 b[ ]中，返回值为实际读取的字节的长度数量，没有内容要读取了则返回-1。
int read( byte b[ ], int off, int len ); //将数据读取到部分字节数组中，即读取len个字节，放置到以下标off开始的字节数组b[ ]中，返回值为实际读取的字节的长度数量
int available( ); //返回值为流中尚未读取的字节的数量
long skip( long n )； //读指针跳过n个字节不读，返回值为实际跳过的字节数量
close( ); //流操作完毕后必须关闭 ，否则容易造成内存泄漏；
使用输入流中的标记：
void mark( int readlimit ); //记录当前读指针所在位置，readlimit 表示读指针读出readlimit个字节后所标记的指针位置才失效
void reset( ); //把读指针重新指向用mark方法所记录的位置
boolean markSupported( ); //当前的流是否支持读指针的记录功能
2．OutputStream 字节输出流：将数据从内存缓存或者网上写到文件中
定义文件句柄包含要输出到的文件的路径:"d:/Demo/Text.txt"
File file=new File("d:"+File.separator+"Demo"+File.separator+"Text.txt");
OutputStream是个抽象类，需要通过FileOutputStream子类向上转型完成其实例化：
OutputStream outputStream=new FileOutputStream(file);
子类的构造方法(1)：FileOutputStream( File file)：将内容输出到指定的路径，如果文件已存在则使用新的内容覆盖旧的文件。
子类的构造方法(2)：FileOutputStream( File file,Boolean append)：将内容输出到指定的路径，如果将append设置为true表示将新的内容追加到文件中，否则使用新的内容覆盖旧的文件内容。
输出数据：
void write( int b ); //输出单个字节b到文件中 ；
void write( byte b[ ] ); //输出字节数组b[ ]的数据到文件中；
void write( byte b[ ], int off, int len ); //输出部分字节数组的数据到文件即把字节数组b中从下标off开始，长度为len的字节输出；
flush( ) //刷空输出流，并输出所有被缓存的字节，由于某些流支持缓存功能，该方法将把缓存中所有内容强制输出到流中。
close( ); //流操作完毕后必须关闭，否则容易造成内存泄漏；
下面给出一个文件下载的例子,里面有计算文件下载进度的代码，包括使用Handler消息机制发送下载进度消息到主线程更新进度：
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Response;
/**
* @文件描述：专门处理文件下载回调
*/
public class CommonFileCallback implements Callback {
/**
* the java layer exception, do not same to the logic error
*/
protected final int NETWORK_ERROR = -1; // the network relative error
protected final int IO_ERROR = -2; // the JSON relative error
protected final String EMPTY_MSG = "";
/**
* 将其它线程的数据转发到UI线程
*/
private static final int PROGRESS_MESSAGE = 0x01;//处理进度的消息类型
private Handler mDeliveryHandler;
private DisposeDownloadListener mListener;
//下载文件的路径
private String mFilePath;
//当前的进度
private int mProgress;
public CommonFileCallback(DisposeDataHandle handle) {
this.mListener = (DisposeDownloadListener) handle.mListener;
this.mFilePath = handle.mSource;
this.mDeliveryHandler = new Handler(Looper.getMainLooper()) {
//因为需要处理进度，这里要重写handleMessage（）方法
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case PROGRESS_MESSAGE:
mListener.onProgress((int) msg.obj);
break;
}
}
};
}
@Override
public void onFailure(final Call call, final IOException ioexception) {
mDeliveryHandler.post(new Runnable() {
@Override
public void run() {
mListener.onFailure(new OkHttpException(NETWORK_ERROR, ioexception));
}
});
}
@Override
public void onResponse(Call call, Response response) throws IOException {
final File file = handleResponse(response);
mDeliveryHandler.post(new Runnable() {
@Override
public void run() {
if (file != null) {
//将文件file回调到业务层
mListener.onSuccess(file);
} else {
mListener.onFailure(new OkHttpException(IO_ERROR, EMPTY_MSG));
}
}
});
}
/**
* 此时还在子线程中，不则调用回调接口
*
* @param response
* @return
*/
private File handleResponse(Response response) {
if (response == null) {
return null;
}
InputStream inputStream = null;
File file = null;
FileOutputStream fos = null;
//缓存数组，每次写文件写多少数据
byte[] buffer = new byte[2048];
int length;
//计算进度用的当前文件长度大小
int currentLength = 0;
//计算进度用的文件总长度
double sumLength;
try {
//检查文件路径是否存在
checkLocalFilePath(mFilePath);
file = new File(mFilePath);
fos = new FileOutputStream(file);
//OKHttp网络请求的数据内容response，创建输入流对象
inputStream = response.body().byteStream();
//文件内容的总长度
sumLength = (double) response.body().contentLength();
//输入流从网络中将数据读到缓冲区
while ((length = inputStream.read(buffer)) != -1) {
//将buffer中的数据写入到文件
fos.write(buffer, 0, length);
currentLength += length;
//计算进度
mProgress = (int) (currentLength / sumLength * 100);
//发送消息，将进度发送到目标MessageQueue消息队列
mDeliveryHandler.obtainMessage(PROGRESS_MESSAGE,
mProgress).sendToTarget();
}
fos.flush();
} catch (Exception e) {
file = null;
} finally {
try {
if (fos != null) {
fos.close();
}
if (inputStream != null) {
inputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return file;
}
//判断当前文件的路径是否存在，不存在则创建路径
private void checkLocalFilePath(String localFilePath) {
//获取文件路径
File path = new File(localFilePath.substring(0, localFilePath.lastIndexOf("/") + 1));
//创建文件句柄
File file = new File(localFilePath);
if (!path.exists()) {
path.mkdirs();
}
if (!file.exists()) {
try {
//通过文件句柄创建新文件
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
