整理几种io流复制文本的方法，分别用到字符输入输出流，字节输入输出流，缓冲流，转换流，8种方法

整理几种io流复制文本的方法，分别用到字符输入输出流，字节输入输出流，缓冲流，转换流，还可以扩展好几个，比如缓冲流，转换流复制，这个可以高效实现复制
复制文本的同时输出到控制台，
package io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
//学习用自己最好理解的

/*

• 复制文本文件（8种方式）
  */
  public class Io_mentod_copy {
  public static void main(String[] args) throws IOException {
  //路径自己修改
  String src=“F:/java资料/io/iotest读.txt”;
  String dest=“F:/java资料/io/iotest写.txt”;

   //基本流一次读取一个字符
   //mentod1(src, dest);
  
   //基本流一次读取一个字符数组
   //mentod2(src, dest);
  
   //缓冲流一次读取一个字符
   //mentod3(src, dest);
  
   //缓冲流一次读取一个字符数组
  
   //mentod4(src, dest);
  
   //缓冲流特殊方法一次读写一个字符串
   //mentod5(src, dest);
  
   //用字节流一次读写一个字节数组
   //mentod6(src, dest);
   
   //转换流，字节流复制，一次一个字节
   //mentod7(src, dest);
  
   //在outputStreamWriter类中需要一个字节流输出输入对象。
   mentod8(src, dest);
  

  }
  //在outputStreamWriter类中需要一个字节流输出输入对象。
  private static void mentod8(String src, String dest)
  throws FileNotFoundException, IOException {
  //字节输入流
  FileInputStream fis=new FileInputStream(src);
  //字节输出流
  FileOutputStream fos=new FileOutputStream(dest);
  //转换流
  OutputStreamWriter osw=new OutputStreamWriter(fos);
  InputStreamReader isr=new InputStreamReader(fis);

   String str="方法八复制：字节流转换流复制，一次一个字符数组\r\n";
   osw.write(str);
  
   int len;
   char[] chs=new char[1024];
  
   while((len=isr.read(chs))!=-1){
   	osw.write(new String(chs,0,len));
   	osw.flush();
  
   	System.out.print(new String(chs,0,len));
  
   }
   isr.close();
   osw.close();
  

// fis.close();
// fos.close();
}

//转换流，字节流复制，一次一个字节
private static void mentod7(String src, String dest)
throws FileNotFoundException, IOException {
	//在outputStreamWriter类中需要一个字节流输出输入对象。
	FileInputStream fis=new FileInputStream(src);
	FileOutputStream fos=new FileOutputStream(dest);
	//转换流
	OutputStreamWriter osw=new OutputStreamWriter(fos);
	InputStreamReader isr=new InputStreamReader(fis);

	String str="方法七复制：字节流转换流复制，一次一个字符\r\n";
	osw.write(str);
	//将字符串转换为字节数组
	//fos.write(str.getBytes());

	int len;
	while((len=isr.read())!=-1){
		osw.write(len);
		osw.flush();

		System.out.print((char)len);

	}
	isr.close();
	osw.close();

// fis.close();
// fos.close();
}

//用字节流一次读写一个字节数组
private static void mentod6(String src, String dest)
throws FileNotFoundException, IOException {
	FileInputStream fis=new FileInputStream(src);

	FileOutputStream fos=new FileOutputStream(dest);

	String str="方法六复制：字节流复制一个字节数组\r\n";
	fos.write(str.getBytes());
	byte[] bys=new byte[1024];
	int len;
	while((len=fis.read(bys))!=-1){
		fos.write(bys);
		fos.flush();

		System.out.println(new String(bys,0,len));
	}

	fis.close();
	fos.close();
}

//缓冲流特殊方法一次读写一个字符串
private static void mentod5(String src, String dest)
throws FileNotFoundException, IOException {
	BufferedReader br=new BufferedReader(new FileReader(src));

	BufferedWriter bw=new BufferedWriter(new FileWriter(dest));

	bw.write("方法五复制：缓冲流复制\r\n");
	String line;
	while((line=br.readLine())!=null){
		bw.write(line);
		bw.newLine();
		bw.flush();
		//输出到控制台
		System.out.println(line);
	}
	bw.close();
	br.close();
}

//缓冲流一次读取一个字符数组
private static void mentod4(String src, String dest)
throws FileNotFoundException, IOException {
	BufferedReader br=new BufferedReader(new FileReader(src));

	BufferedWriter bw=new BufferedWriter(new FileWriter(dest));

	bw.write("方法四复制：缓冲流一次读取取一个字符数组\r\n");

	char[] chs=new char[1024];
	int len;
	while((len=br.read(chs))!=-1){
		bw.write(chs, 0, len);
		bw.flush();
		//输出到控制台
		System.out.println(new String(chs,0,len));
	}
	bw.close();
	br.close();
}

//缓冲流一次读取一个字符
private static void mentod3(String src, String dest)
throws FileNotFoundException, IOException {
	BufferedReader br=new BufferedReader(new FileReader(src));

	BufferedWriter bw=new BufferedWriter(new FileWriter(dest));

	bw.write("方法三复制：缓冲流一次读取取一个字符\r\n");
	int len;
	while((len=br.read())!=-1){
		bw.write(len);
		bw.flush();
		//输出到控制台，注意不要回车ln
		System.out.print((char)len);
	}
	bw.close();
	br.close();
}

//基本流一次读取一个字符数组
private static void mentod2(String src, String dest)
throws FileNotFoundException, IOException {
	FileReader fr=new FileReader(src);

	FileWriter fw=new FileWriter(dest);

	fw.write("方法二复制：基本流一次读取取一个字符数组\r\n");
	char[] chs=new char[1024];
	int len;
	while((len=fr.read(chs))!=-1){
		fw.write(chs,0,len);
		fw.flush();

		System.out.println(new String(chs,0,len));
	}
	fw.close();
	fr.close();
}

//基本流一次读取一个字符
private static void mentod1(String src, String dest)
throws FileNotFoundException, IOException {

	FileReader fr=new FileReader(src);

	FileWriter fw=new FileWriter(dest);
	fw.write("方法一复制：基本流一次读取一个字符\r\n");
	int ch;
	while((ch=fr.read())!=-1){
		fw.write(ch);
		fw.flush();
		//输出到控制台
		System.out.print((char)ch);
	}
	fw.close();
	fr.close();
}

}

//原创不易，转载请标明出处