先说总结:
复制文本文件,既可用字符流方式,也可以用字节流方式.
复制非文本文件,只能用字节流方式.
字符流的读取与写入方式搭配如下:
| 按单个字符 | 按字符数组 | 按行 | |
| 字符输入流FileReader | read() | read(char[] cbuf) | |
| 字符输出流FIleWriter | write(int c) | write(char[] cbuf,int off,int len) | |
| 缓冲字符输入流BufferedFileReader | read() | read(int c) | readLine() |
| 缓冲字符输出流BufferedFileWriter | write(int c) | write(char[] cbuf,int off,int len) | writeLine(String str) |
字节流的读取与写入方式:
| 按单个字节 | 按字节数组 | 按行 | |
| 字节流输入流FileInputStream | read() | read(byte[] b) | |
| 字节输出流FIleOutputStream | write(int c) | write(byte[] b,int off,int len) | |
| 缓冲字节输入流BufferedInputStream | read() | read(byte[] b) | |
| 缓冲字节输出流BufferedOutputStream | write(int c) | write(byte[] b,int off,int len) |
因此,利用Java IO复制文件有如下9种方式:
1.字符流读写复制文件,每次复制一个字符:
/**
* 字符流方式复制文件,一次复制一个字节
* @param srcFilePath 源文件路径
* @param destFilePath 新文件路径
*/
public static void copyFileReaderToWriterChar(String srcFilePath,String destFilePath){
FileReader fileReader = null;
FileWriter fileWriter = null;
try{
fileReader = new FileReader(srcFilePath);
fileWriter = new FileWriter(destFilePath);
int charRead;
while((charRead = fileReader.read()) != -1){//读取单个字符,-1代表已达到流的末尾
fileWriter.write(charRead);//写入单个字符
}
fileWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(null != fileReader){
try{
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != fileWriter){
try{
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.字符流读写复制文件,每次复制一个字符数组:
/**
* 字符流方式复制文件,一次复制一个字符数组
* @param srcFilePath 源文件路径
* @param destFilePath 新文件路径
*/
public static void copyFileReaderToWriterCharArray(String srcFilePath,String destFilePath){
FileReader fileReader = null;
FileWriter fileWriter = null;
try{
fileReader = new FileReader(srcFilePath);
fileWriter = new FileWriter(destFilePath);
char[] charArray = new char[1024];//缓冲数组
int readLength;//每次读取的长度
//
/**
* 每次读取charArray.length个字符存入charArray,-1代表已经到流的末尾
* readLength为读取的长度,一般为charArray.length,最后一次循环时一般不足charArray.length,为实际读取长度
*/
while((readLength = fileReader.read(charArray)) != -1){
fileWriter.write(charArray,0,readLength);//写入读取的字符数组.
}
fileWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(null != fileReader){
try{
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != fileWriter){
try{
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.缓冲字符流读写复制文件,每次复制复制一个字符:
/**
* 使用缓冲字符流复制文件,每次复制一个字符
* @param srcFilePath 源文件
* @param destFilePath 新文件
*/
public static void copyFileBufferedReaderToBufferedWriterChar(String srcFilePath,String destFilePath){
FileReader fileReader = null;
FileWriter fileWriter = null;
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
try{
fileReader = new FileReader(srcFilePath);
fileWriter = new FileWriter(destFilePath);
bufferedReader = new BufferedReader(fileReader);
bufferedWriter = new BufferedWriter(fileWriter);
int charRead;//保存每次循环读取的字符
while ((charRead = bufferedReader.read()) != -1){//读取一个字符,-1代表读到流末尾
bufferedWriter.write(charRead);//写入读到的字符
}
bufferedWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(null != fileReader){
try{
fileReader.close();
}catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedReader){
try{
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != fileWriter){
try{
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedWriter){
try{
bufferedWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4.缓冲字符流读写复制文件,每次复制一个字符数组:
/**
* 使用缓冲字符流复制文件,每次复制一个字符数组
* @param srcFilePath 源文件
* @param destFilePath 新文件
*/
public static void copyFileBufferedReaderToBufferedWriterCharArray(String srcFilePath,String destFilePath){
FileReader fileReader = null;
FileWriter fileWriter = null;
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
try{
fileReader = new FileReader(srcFilePath);
fileWriter = new FileWriter(destFilePath);
bufferedReader = new BufferedReader(fileReader);
bufferedWriter = new BufferedWriter(fileWriter);
char[] charArray = new char[1024];
int lengthRead;
while ((lengthRead = bufferedReader.read(charArray)) != -1){//读取一个字符,-1代表读到流末尾
bufferedWriter.write(charArray,0,lengthRead);//写入读到的字符
}
bufferedWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(null != fileReader){
try{
fileReader.close();
}catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedReader){
try{
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != fileWriter){
try{
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedWriter){
try{
bufferedWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
5.缓冲字符流读写复制文件,每次复制一行:
/**
* 使用缓冲字符流复制文件,每次复制一行
* @param srcFilePath 源文件
* @param destFilePath 新文件
*/
public static void copyFileBufferedReaderToBufferedWriterString(String srcFilePath,String destFilePath){
FileReader fileReader = null;
FileWriter fileWriter = null;
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
try{
fileReader = new FileReader(srcFilePath);
fileWriter = new FileWriter(destFilePath);
bufferedReader = new BufferedReader(fileReader);
bufferedWriter = new BufferedWriter(fileWriter);
String lineRead;
while ((lineRead = bufferedReader.readLine()) != null){//读取一行,null代表已经读到流末尾
bufferedWriter.write(lineRead);
bufferedWriter.newLine();
bufferedWriter.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(null != fileReader){
try{
fileReader.close();
}catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedReader){
try{
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != fileWriter){
try{
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedWriter){
try{
bufferedWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
6.字节流读写复制文件,每次复制一个字节:
/**
* 字节流方式复制文件,一次复制一个字节
* @param srcFilePath 源文件路径
* @param destFilePath 新文件路径
*/
public static void copyFileInputStreamToOutputStreamChar(String srcFilePath,String destFilePath){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try{
fileInputStream = new FileInputStream(srcFilePath);
fileOutputStream = new FileOutputStream(destFilePath);
int charRead;
while((charRead = fileInputStream.read()) != -1){//读取单个字节,-1代表已达到流的末尾
fileOutputStream.write(charRead);//写入单个字节
}
fileOutputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(null != fileInputStream){
try{
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != fileOutputStream){
try{
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
7.字节流读写复制文件,每次复制一个字节数组:
/**
* 字节流方式复制文件,一次复制一个字节数组
* @param srcFilePath 源文件路径
* @param destFilePath 新文件路径
*/
public static void copyFileInputStreamToOutputStreamCharArray(String srcFilePath,String destFilePath){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try{
fileInputStream = new FileInputStream(srcFilePath);
fileOutputStream = new FileOutputStream(destFilePath);
byte[] byteArray = new byte[1024];
int readLength;//每次读取的长度
//
/**
* 每次读取byteArray.length个字符存入byteArray,-1代表已经到流的末尾
* readLength为读取的长度,一般为byteArray.length,最后一次循环时一般不足byteArray.length,为实际读取长度
*/
while((readLength = fileInputStream.read(byteArray)) != -1){
fileOutputStream.write(byteArray,0,readLength);//写入读取的字节数组.
}
fileOutputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(null != fileInputStream){
try{
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != fileOutputStream){
try{
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
8.缓冲字节流读写复制文件,每次复制一个字节:
/**
* 使用缓冲字节流复制文件,每次复制一个字节
* @param srcFilePath 源文件
* @param destFilePath 新文件
*/
public static void copyFileBufferedInputStreamToBufferedOutputStreamChar(String srcFilePath,String destFilePath){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
try{
fileInputStream = new FileInputStream(srcFilePath);
fileOutputStream = new FileOutputStream(destFilePath);
bufferedInputStream = new BufferedInputStream(fileInputStream);
bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
int charRead;
while((charRead = bufferedInputStream.read()) != -1){//读取单个字节,-1代表已达到流的末尾
bufferedOutputStream.write(charRead);//写入单个字节
}
bufferedOutputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(null != fileInputStream){
try{
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != fileOutputStream){
try{
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedInputStream){
try{
bufferedInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedOutputStream){
try{
bufferedOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
9.缓冲字节流读写复制文件,每次复制一个字节数组:
/**
* 使用缓冲字节流复制文件,每次复制一个字节数组
* @param srcFilePath 源文件
* @param destFilePath 新文件
*/
public static void copyFileBufferedInputStreamToBufferedOutputStreamCharArray(String srcFilePath,String destFilePath){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
try{
fileInputStream = new FileInputStream(srcFilePath);
fileOutputStream = new FileOutputStream(destFilePath);
bufferedInputStream = new BufferedInputStream(fileInputStream);
bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
byte[] byteArray = new byte[1024];
int readLength;//每次读取的长度
//
/**
* 每次读取byteArray.length个字符存入byteArray,-1代表已经到流的末尾
* readLength为读取的长度,一般为byteArray.length,最后一次循环时一般不足byteArray.length,为实际读取长度
*/
while((readLength = bufferedInputStream.read(byteArray)) != -1){
bufferedOutputStream.write(byteArray,0,readLength);//写入读取的字节数组.
}
bufferedOutputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(null != fileInputStream){
try{
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != fileOutputStream){
try{
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedInputStream){
try{
bufferedInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(null != bufferedOutputStream){
try{
bufferedOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
显然,复制效率上,使用缓冲流快于不适用缓冲流;按数组快于按单个字符/字节;字符数组快于字节数组;
因此,
复制文本文件,使用方法4,缓冲字符流读写复制文件,每次复制一个字符数组.
复制非文本文件,使用方法9,缓冲字节流读写复制文件,每次复制一个字节数组.
参考:
https://www.cnblogs.com/pony1223/p/8030200.html