【我的Java笔记】IO流_使用IO流进行文件的复制和粘贴

IO流中文件复制粘贴的操作步骤：

1.数据源文件-------->输入流-------->读数据

2.目的地文件-------->输出流-------->写数据

一、文本文件（优先采用字符流）

注：读取速度最快：采用高效字符输入流中的一次读取一个字符数组速度最快（ new BufferReader(new FileReader()) ）

写入速度最快：采用高效字符输出流（ new BufferedWriter(new FileWriter()) ）

文本文件复制粘贴的六种方式

例1：使用高效字符输入流一次读取一个字符数组（效率最高）

/**
* 需求：将项目下的a.txt文件复制到b.txt中
*/

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.BufferedWriter;

public class CopyFileDemo {

public static void main(String[] args) throws IOException {

// 封装数据源:
// 创建一个文件字节输入流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 封装目的地
// 创建文件输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

// 一次读取一个字符数组
char[] chs = new char[1024];
int len = 0;
while ((len = br.read(chs)) != -1) {
// 一次读一个字符数组，使用输出流给b.txt文件写一个字符数组
bw.write(chs, 0, len);
//刷新流
bw.flush();
}

// 释放资源
br.close();
bw.close();
}
}

例2：采用高效字符输入流一次读取一个字符

/**
* 需求：将项目下的a.txt文件复制到b.txt中
*/

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.BufferedWriter;

public class CopyFileDemo {

public static void main(String[] args) throws IOException {

// 封装数据源:
// 创建一个文件字节输入流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 封装目的地
// 创建文件输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

// 一次读取一个字符
int ch = 0;
while ((ch = br.read()) != -1) {
// 一次读一个字符，使用输出流给b.txt文件写一个字符
bw.write(ch);
//刷新流
bw.flush();
}

// 释放资源
br.close();
bw.close();
}
}

例3：采用高效字符输入流中的特有方法：public String readLine() 一次读取一行

/**
* 需求：将项目下的a.txt文件复制到b.txt中
*/

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.BufferedWriter;

public class CopyFileDemo {

public static void main(String[] args) throws IOException {

// 封装数据源:
// 创建一个文件字节输入流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 封装目的地
// 创建文件输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

// 使用Buffe
4000
redReader中的特有功能public String readLine() 一次读取一行
String str = null;
while ((str = br.readLine()) != null) {
// 一次读一行，使用输出流给b.txt文件写入此行字符串
bw.write(str);
//BufferedWriter中的特有功能public void newLine() 写入一个分行符
bw.newLine();
//刷新流
bw.flush();
}

// 释放资源
br.close();
bw.close();
}
}

例4：采用基本字符输入流，一次读取一个字符数组

/**
* 需求：将项目下的a.txt文件复制到b.txt中
*/

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFileDemo {

public static void main(String[] args) throws IOException {

// 封装数据源:
// 创建一个文件字节输入流对象
FileReader fr = new FileReader("a.txt");
// 封装目的地
// 创建文件输出流对象
FileWriter fw = new FileWriter("b.txt");

// 使用基本字符输入流，一次读取一个字符数组
char[] chs = new char[1024];
int len = 0;
while ((len = fr.read(chs)) != -1) {
// 一次读一个字符数组，使用输出流给b.txt文件写一个字符数组
fw.write(chs, 0, len);
// 刷新流
fw.flush();
}

// 释放资源
fr.close();
fw.close();
}
}

例5：采用基本字符输入流，一次读取一个字符（效率最低）

/**
* 需求：将项目下的a.txt文件复制到b.txt中
*/

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFileDemo {

public static void main(String[] args) throws IOException {

// 封装数据源:
// 创建一个文件字节输入流对象
FileReader fr = new FileReader("a.txt");
// 封装目的地
// 创建文件输出流对象
FileWriter fw = new FileWriter("b.txt");

// 使用基本字符输入流，一次读取一个字符
int ch = 0;
while ((ch = fr.read()) != -1) {
// 一次读一个字符，使用输出流给b.txt文件写一个字符
fw.write(ch);
// 刷新流
fw.flush();
}

// 释放资源
fr.close();
fw.close();
}
}

方式6：采用打印流PrintWriter的println()方法进行文件的复制

/*
* 需求：将当前项目下的“学生成绩.txt”复制到当前项目下的“复制学生成绩.txt”
* */

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriterCopyDemo {
public static void main(String[] args) throws IOException {

// 封装数据源
BufferedReader br = new BufferedReader(new FileReader("学生成绩.txt"));

// 封装目的地，使用字符打印流对象并启动自动刷新功能
PrintWriter pw = new PrintWriter(new FileWriter("复制学生成绩.txt"), true); // 此种构造方式可以自动刷新

// 读取数据
String line = null;
while ((line = br.readLine()) != null) {
// 写入数据，读取一行并启动自动换行
pw.println(line);
}

// 释放资源
br.close();
pw.close();
}
}

方式7：采用SquenceInputStream合并流的构造方法进行多个文件的复制

（1）public SequenceInputStream(InputStream s1,InputStream s2)
两个文件的复制

/*
* 需求：将当前项目下的文件“s.txt”和“ss.txt”复制到“sss.txt”中
* */

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;

public class SequenceInputStreamDemo {
public static void main(String[] args) throws IOException {
// 分别封装这个两个源数据文件
InputStream s1 = new FileInputStream("s.txt");
InputStream s2 = new FileInputStream("ss.txt");

// 创建合并流对象封装这两个源数据文件
SequenceInputStream sis = new SequenceInputStream(s1, s2);

// 封装目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("sss.txt"));

// 一次读取一个字节数组写入数据
byte[] bys = new byte[1024];
int len = 0;
while ((len = sis.read(bys)) != -1) {
// 写数据
bos.write(bys, 0, len);
bos.flush();
}

// 释放资源
sis.close();
bos.close();
}
}

（2）public SequenceInputStream(Enumeration<? extends InputStream> e)
多个文件的复制
/*
* 需求：将文件s.txt，ss.txt和sss.txt复制到ssss.txt文件中
* */

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class SequenceInputStreamDemo1 {

public static void main(String[] args) throws IOException {

// 创建一个Vector集合,泛型数据类型<InputStream>
Vector<InputStream> v = new Vector<InputStream>();

// 封装者三个java文件
InputStream s1 = new FileInputStream("s.txt");
InputStream s2 = new FileInputStream("ss.txt");
InputStream s3 = new FileInputStream("sss.txt");

// 添加到集合中
v.add(s1);
v.add(s2);
v.add(s3);

// 调用Vector集合的特有功能:public Enumeration<E> elements()
Enumeration<InputStream> en = v.elements();
// 创建合并流对象
SequenceInputStream sis = new SequenceInputStream(en);
// 封装目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("ssss.txt"));

// 一次读取一个字节数组
byte[] bys = new byte[1024];
int len = 0;
while ((len = sis.read(bys)) != -1) {
// 写数据
bos.write(bys, 0, len);
bos.flush();
}

// 释放资源
bos.close();
sis.close();
}
}

二、视频，音频，动画，图片文件（优先采用字节流）

注：读取速度最快：采用高效字节输入流中的一次读取一个字节数组速度最快（new BufferedInputStream(new FileInputStream()) ）

写入速度最快：采用高效字节输出流（ new BufferedOutputStram(new FileOutputStream()) ）

字节型文件复制粘贴的四种方式

例1：采用高效字节流，一次读取一个字节数组（效率最高）

/**
* 需求：将项目下的Reus.jpg文件复制到Marco.jpg中
*/

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFileDemo {

public static void main(String[] args) throws IOException {
//获取当前的系统时间
long startTime = System.currentTimeMillis() ;

// 封装数据源:
// 创建一个文件字节输入流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Reus.jpg"));
// 封装目的地
// 创建文件输出流对象
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Marco.jpg"));

// 使用高效字节输入流，一次读取一个字节数组
byte [] bys = new byte [1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
// 一次读一个字节数组，使用输出流给Marco.jpg文件写一个字节数组
bos.write(bys,0,len);
// 刷新流
bos.flush();
}

// 释放资源
bis.close();
bos.close();

//时间测试
long endTime = System.currentTimeMillis() ;
System.out.println("共耗时:"+(endTime-startTime)+"毫秒");		//2毫秒
}
}

例2：采用高效字节输入流，一次读一个字节

/**
* 需求：将项目下的Reus.jpg文件复制到Marco.jpg中
*/

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFileDemo {

public static void main(String[] args) throws IOException {
//获取当前的系统时间
long startTime = System.currentTimeMillis() ;

// 封装数据源:
// 创建一个文件字节输入流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Reus.jpg"));
// 封装目的地
// 创建文件输出流对象
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Marco.jpg"));

// 使用高效字节输入流，一次读取一个字节
int by = 0;
while ((by = bis.read()) != -1) {
// 一次读一个字节，使用输出流给Marco.jpg文件写一个字节
bos.write(by);
// 刷新流
bos.flush();
}

// 释放资源
bis.close();
bos.close();

//时间测试
long endTime = System.currentTimeMillis() ;
System.out.println("共耗时:"+(endTime-startTime)+"毫秒");		//647毫秒
}
}

例3：采用基本字节输入流，一次读一个字节数组

/**
* 需求：将项目下的Reus.jpg文件复制到Marco.jpg中
*/

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFileDemo {

public static void main(String[] args) throws IOException {
// 获取当前的系统时间
long startTime = System.currentTimeMillis();

// 封装数据源:
// 创建一个文件字节输入流对象
FileInputStream fis = new FileInputStream("Reus.jpg");
// 封装目的地
// 创建文件输出流对象
FileOutputStream fos = new FileOutputStream("Marco.jpg");

// 使用基本字节输入流，一次读取一个字节数组
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read()) != -1) {
// 一次读一个字节数组，使用输出流给Marco.jpg文件写一个字节数组
fos.write(bys, 0, len);
// 刷新流
fos.flush();
}

// 释放资源
fis.close();
fos.close();

// 时间测试
long endTime = System.currentTimeMillis();
System.out.println("共耗时:" + (endTime - startTime) + "毫秒"); // 1249毫秒
}
}

例4：采用基本字节输入流，一次读一个字节

/**
* 需求：将项目下的Reus.jpg文件复制到Marco.jpg中
*/

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFileDemo {

public static void main(String[] args) throws IOException {
// 获取当前的系统时间
long startTime = System.currentTimeMillis();

// 封装数据源:
// 创建一个文件字节输入流对象
FileInputStream fis = new FileInputStream("Reus.jpg");
// 封装目的地
// 创建文件输出流对象
FileOutputStream fos = new FileOutputStream("Marco.jpg");

// 使用基本字节输入流，一次读取一个字节
int by = 0;
while ((by = fis.read()) != -1) {
// 一次读一个字节，使用输出流给Marco.jpg文件写一个字节
fos.write(by);
// 刷新流
fos.flush();
}

// 释放资源
fis.close();
fos.close();

// 时间测试
long endTime = System.currentTimeMillis();
System.out.println("共耗时:" + (endTime - startTime) + "毫秒"); // 1019毫秒
}
}

方式5：采用打印流PrintStream的writer()方法进行图片的复制

/*
* 需求：将当前项目下的“Reus.jpg”复制到当前项目下的“Marco.jpg”
* */

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class PrintStreamCopyDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Reus.jpg"));

// 封装目的地，使用字符打印流对象并启动自动刷新功能
PrintStream ps = new PrintStream(new FileOutputStream("Marco.jpg"), true); // 此种构造方式可以自动刷新

// 读取数据,一次读取一个字节数组
byte [] bys = new byte [1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
// 写入数据，一次写一个字节数组
ps.write(bys,0,len);
}

// 释放资源
bis.close();
ps.close();
}
}