黑马程序员----IO流概述与总结

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

介绍IO流之前先了解一下File类

.File类：

1.构造方法：
File(File parent, String child)：根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。 
File(String pathname)：通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 
File(String parent, String child)：根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
     2.常用方法：
1).创建功能：
public boolean createNewFile()
public boolean mkdir()：创建单级目录
public boolean mkdirs()：创建多级目录
2).删除功能
public boolean delete():能删除文件和目录
3).重命名功能
public boolean renameTo(File dest):在相同目录下是重命名，不同目录下相当于剪切操作；
4).判断功能
public boolean isDirectory():是否是目录
public boolean isFile()：是否是文件
public boolean exists()：文件或目录是否存在
public boolean canRead()：是否可读
public boolean canWrite()：是否可写
public boolean isHidden()：是否隐藏
5).基本获取功能
public String getAbsolutePath():获取绝对路径
public String getPath()：获取File封装的路径
public String getName()：获取文件或目录的名称
public long length()：获取文件的长度。单位：字节
public long lastModified()：获取最后修改时间。单位：毫秒
6).高级获取功能
public String[] list():获取当前File对象下的所有文件及目录的名称。封装成一个String[]数组；
public File[] listFiles()：获取当前File对象下的所有文件及目录的名称。封装成一个File[]数组；

IO流： 1.分类：

按流向分：
1).输出流：
2).输入流；
按数据类型分：
1).字节流:
输入流:InputStream
输出流:OutputStream
2).字符流：
输入流:Reader
输出流:Writer
2.字节流：
输出流：FileOutputStream
构造方法：包含"追加写入"。文件可以不存在，自动创建
成员方法：write(byte[] b);
 write(byte[] b,int off,int len);
输入流：FileInputStream:
构造方法：文件必须存在，否则抛异常；
成员方法：int read():一次读取一个字节
 int read(byte[] b):一次读取一个字节数组，返回读取字节的数量；
3.带缓冲的字节流：
输出流：BufferedOutputStream:
构造方法：需要FileOutputStream
成员方法：没有新增；注意：
flush();刷新缓冲区；
close();此方法内部会自动调用flush();
输入流：BufferedInputStream:
构造方法：需要FileInputStream
成员方法：没有新增：
 一次读取一个字节；
 一次读取一个字节数组；
4.对于字节流，推荐使用带缓冲区的；
close()和flush()的区别：
flush()：将缓冲区的数据刷到目的地中后，流可以使用。
close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。

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

/*
 * 复制视频：
 * 1.FileInputStream
 * 	 FileOutputStream:一次读取一个字节:method1():60489 毫秒
 * 2.FileInputStresam
 * 	 FileOutputStream:一次读取一个字节数组:method2():122毫秒
 * 3.BufferedInputStream
 * 	 BufferedOutputStream:一次读取一个字节::method3():1003 毫秒
 * 4.BufferedOutputStream
 * 	 BufferedInputStream:一次读取一个字节数组::method4():69 毫秒
 * 
 * 当使用字节流时，优先考虑使用带缓冲区的类，要自己定义一个大些的数组，用于辅助缓冲；
 */
public class Demo {
	public static void main(String[] args) {
		try {
			long start = System.currentTimeMillis();
		//	method1();//60489 毫秒
		//	method2();//122毫秒
		//	method3();//1003 毫秒
			method4();//69 毫秒
			long end = System.currentTimeMillis();
			System.out.println("时间：" + (end - start) + " 毫秒");
			
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	//BufferedOutputStream,BufferedInputStream:一次读取一个字节数组
	private static void method4()  throws IOException{
		BufferedInputStream bufIn = new BufferedInputStream(new FileInputStream("哥有老婆_copy.mp4"));
		BufferedOutputStream bufOut = new BufferedOutputStream(new FileOutputStream("哥有老婆_copy_4.mp4"));
		byte[] byteArray = new byte[1024];
		int len = 0;
		while((len = bufIn.read(byteArray)) != -1){
			bufOut.write(byteArray,0,len);
		}
		bufIn.close();
		bufOut.close();
	}
	//BufferedInputStream,BufferedOutputStream:一次读取一个字节
	private static void method3() throws IOException{
		BufferedInputStream bufIn = new BufferedInputStream(new FileInputStream("哥有老婆_copy.mp4"));
		BufferedOutputStream bufOut = new BufferedOutputStream(new FileOutputStream("哥有老婆_copy_3.mp4"));
		int n = 0;
		while((n = bufIn.read()) != -1){
			bufOut.write(n);
		}
		bufIn.close();
		bufOut.close();
	}
	
	//FileInputStresam,FileOutputStream:一次读取一个字节数组
	private static void method2() throws IOException {
		FileInputStream in = new FileInputStream("哥有老婆_copy.mp4");
		FileOutputStream out = new FileOutputStream("哥有老婆_copy_2.mp4");
		byte[] byteArray = new byte[1024];
		int len = 0;
		while((len = in.read(byteArray)) != -1){
			out.write(byteArray,0,len);
		}
		in.close();
		out.close();
		
	}
	//FileInputStream FileOutputStream:一次读取一个字节
	private static void method1() throws IOException {
		FileInputStream in = new FileInputStream("哥有老婆_copy.mp4");
		FileOutputStream out = new FileOutputStream("哥有老婆_copy_1.mp4");
		int n = 0;
		while((n = in.read()) != -1 ){
			out.write(n);
		}
		in.close();
		out.close();
		
	}
}

转换流
字符流
(1)字节流操作中文数据不是特别的方便，所以就出现了转换流。
  转换流的作用就是把字节流转换字符流来使用。
(2)转换流其实是一个字符流
字符流 = 字节流 + 编码表
(3)编码表
A:就是由字符和对应的数值组成的一张表
B:常见的编码表
ASCII
ISO-8859-1
GB2312
GBK
GB18030
UTF-8
C:字符串中的编码问题
编码
String -- byte[]
解码
byte[] -- String
(4)IO流中的编码问题
A:OutputStreamWriter
OutputStreamWriter(OutputStream os):默认编码，GBK
OutputStreamWriter(OutputStream os,String charsetName):指定编码。
B:InputStreamReader
InputStreamReader(InputStream is):默认编码，GBK
InputStreamReader(InputStream is,String charsetName):指定编码
C:编码问题其实很简单
编码只要一致即可
(5)字符流
Reader
|--InputStreamReader
|--FileReader

|--BufferedReader
Writer
|--OutputStreamWriter
  public void write(int c)：一次写入一个字符；
  public void write(char[] cbuf)：一次写入一个字符数组
  public void write(char[] cbuf,int off,int len)：写入字符数组的一部分。
  public void write(String str)：一次写入一个字符串
public void write(String str,int off,int len)：写入字符串的一部分；     
|--FileWriter
|--BufferedWriter
(6)复制文本文件(5种方式)

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

/*
 * 复制文本文件的5种方式：
 * 
 * 复制文本文件：字符流：
 * 
 * 1.OutputStreamWriter:
 * 	 InputStreamReader:
 * 2.FileWriter:
 * 	 FileReader:
 * 		一次读写一个字符；	method1();
 * 		一次读写一个字符数组；	method2();
 * 3.BufferedWriter:
 * 	 BufferedReader:
 * 		一次读写一个字符；	method3();	
 * 		一次读写一个字符数组；	method4();
 * 
 * 	 	一次读写一行数据；	method5();
 * 
 */
public class Demo {
	public static void main(String[] args) {
		try{
	//	method1();
	//	method2();
	//	method3();
	//	method4();
		method5();
		}catch(IOException e){
			e.printStackTrace();
		}
		System.out.println("复制完毕");
	}

	
	//使用FileWriter和FileReader一次读写一个字符
	private static void method1() throws IOException {
		//构造读写对象
		FileReader in = new FileReader("FileWriter.txt");
		FileWriter out = new FileWriter("method1_copy.txt");
		
		//一次读写一个字符
		int n = 0;
		while((n = in.read()) != -1){
			out.write(n);
		}
		in.close();
		out.close();
	}
	//使用FileWriter和FileReader一次读写一个字符数组
	private static void method2() throws IOException {
		//构造读写对象
		FileReader in = new FileReader("FileWriter.txt");
		FileWriter out = new FileWriter("method2_copy.txt");
		//一次读写一个字符数组
		char[] charArray = new char[1024];
		int len = 0;
		while((len = in.read(charArray)) != -1){
			out.write(charArray, 0, len);
			out.flush();
		}
		in.close();
		out.close();
		
	}
	//使用BufferedWriter和BufferedReader一次读写一个字符
	private static void method3() throws IOException{
		BufferedReader in = new BufferedReader(new FileReader("FileWriter.txt"));
		BufferedWriter out = new BufferedWriter(new FileWriter("method3_copy.txt"));
		
		//一次读写一个字符
		int n = 0;
		while((n = in.read()) != -1){
			out.write(n);
		}
		in.close();
		out.close();
		
	}
	//使用BufferedWriter和BufferedReader一次读写一个字符数组
	private static void method4() throws IOException {
		BufferedReader in = new BufferedReader(new FileReader("FileWriter.txt"));
		BufferedWriter out = new BufferedWriter(new FileWriter("method4_copy.txt"));
		
		//一次读写一个字符数组
		char[] charArray = new char[1024];
		int len = 0;
		while((len = in.read(charArray)) != -1){
			out.write(charArray,0,len);
			out.flush();
		}
		in.close();
		out.close();
	}
	//使用BufferedWriter和BufferedReader一次读写一行数据
	private static void method5() throws IOException{
		BufferedReader in = new BufferedReader(new FileReader("FileWriter.txt"));
		BufferedWriter out = new BufferedWriter(new FileWriter("method5_copy.txt"));
		
		String str = null;
		while((str = in.readLine()) != null){
			out.write(str);
			out.newLine();
			out.flush();
		}
		in.close();
		out.close();
	}
}