【Java基础知识】IO流--字节流读写数据以及复制文件的几种方式

1、IO的分类

A、按照流向【参照物JVM】
输入流 : 读取数据
输出流 : 写出数据
B、按照数据类型
(1)字节流
a、字节输入流 读取数据 InputStream
b、字节输出流 写出数据 OutputStream
(2)字符流
a、字符输入流 读取数据 Reader
b、字符输出流 写出数据 Writer

注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。

注意：每种基类的子类都是以父类名作为后缀名。
XxxOutputStream
XxxInputStream
XxxReader
XxxWriter

2、字节流的抽象父类 及基本方法

InputStream【抽象类】输入流:JVM从中连续读取字节的对象。

int read()：从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值，如果返回-1表示遇到流的末尾，结束。
int read(byte[] b)：读入b.length个字节放到b中，并返回实际读入的字节。
int read(byte[] b,int off,int len)：这个方法表示把流中的数据读到,数组b中,第off个开始的len个数组元素中。
void close()：在操作完一个流后要使用此方法将其关闭， 系统就会释放与这个流相关的资源。

OutputStream【抽象类】输出流：JVM向其中连续写入的对象。

void write(int b)：将指定的字节写入此输出流。
void write(byte[] b)：将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b,int off, int len)：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
void flush()：刷新此输出流，并强制写出所有缓冲的输出字节。【彻底完成输出并清空缓冲区】。

3、为何需要调用close()方法？为什么需要缓冲？使用缓冲区技术的优缺点？

3.1为什么需要调用close()方法？

尽管在调用流对象的，在没有引用变量指向它时会变成垃圾，最终垃圾回收器会自动回收。在程序创建一个IO流对象，除了Java程序中我们可见的实例对象外，还有系统本身的资源，Java垃圾回收器只能管理程序中的类的实例对象，没法去管理系统产生的资源，所以程序需要调用close方法，去通知系统释放其自身产生的资源。

3.2 为何需要缓冲区？缓冲技术的优缺点？

计算机访问外部设备,要比直接访问内存慢得多,如果我们每一次write方法的调用都直接写到外部设备(如直接写入硬盘文件),CPU就要花费更多的时间等待外部设备；如果我们开辟一个内存缓冲区,程序的每一次write方法都是写到这个内存缓冲区中,只有这个缓冲区被装满后,系统才将这个缓冲区的内容一次集中写到外部设备。
优点：有效的提高了CPU效率。
缺点：由于缓冲区，数据并没有立即写入到目标中去，就会造成一定的滞后。
缓冲区技术的实现是由编程语言本身决定的：
C语言：默认情况下就会使用缓冲区。
Java:有的类使用了缓冲区，有的类没有使用缓冲区。
flush()方法在缓冲区没有满的情况下，也将缓冲区的内容强制写入外设【刷新】。在调用close()方法，系统在关闭这个流之前也会将缓冲区的内容刷新到硬盘文件。

4、OutputStream输出流的write()方法使用

如何向文本中写入字节？如何实现数据追加？如何实现数据换行？

4.1 直接写入字节

public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("IO.txt");
		fos.write("hello,IO".getBytes());//获取本地编码的字节数组，并写入文本文件中。
		fos.write("java".getBytes());
		fos.close();
	}
}
/* IO.txt的内容：
   hello,IOjava
*/

4.2 写入字节的3种方式

public class FileOutputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		//如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
		FileOutputStream fos = new FileOutputStream("IO.txt", true);		
		fos.write(65); //65 -- 底层二进制数据	-- 通过记事本打开 -- 找65对应的字符值 -- a
		byte[] bys={97,98,99,100,101};
		fos.write(bys);
		fos.write(bys,1,3);
		fos.close();
	}
}
/*  IO.txt文本的内容：
	Aabcdebcd
*/

4.3关于数据换行

不同的系统针对不同的换行符号识别是不一样的。
1、windows:\r\n
2、linux:\n
3、Mac:\r

public class FileOutputStreamDemo3 {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("IO.txt", true);
		// 写数据
		for (int x = 0; x < 3; x++) {
			fos.write(("Hello Java" + x).getBytes());
			fos.write("\r\n".getBytes());
		}
		fos.close();
	}
}
/*  IO.txt文本的内容：
Hello Java0
Hello Java1
Hello Java2
*/

4.4 IO流异常处理的代码

开发中还必须考虑异常处理情况下的输入流的操作

public class FileOutputStreamDemo4 {
	public static void main(String[] args) {
		//为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream("IO.txt");
			fos.write("Java,Hello".getBytes());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//如果fos不是null，才需要close()
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

5、InputStream输入流的read()方法使用

输入流操作

public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("IO.txt");
		int by = 0;
		//读取，赋值，判断
		while ((by = fis.read()) != -1) {
			System.out.print((char)by);
		}
		fis.close();
	}
}

6、通过IO流进行文件复制

6.1 基本的文件复制

public class CopyFileDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("a.txt");
		FileOutputStream fos = new FileOutputStream("b.txt");
		int by = 0;
		while ((by = fis.read()) != -1) {
			fos.write(by);
		}
		fos.close();
		fis.close();
	}
}

6.2 计算机是如何识别应该把2个字节转换为一个汉字？

在GBK字符编码集中，汉字是由2个字节组成，因为GBK兼容ISO-8859-1,正数的单字节已被占用
所以汉字的第一个字节必须为负数第二个字节大多也为负数。如：

public class StringDemo {
	public static void main(String[] args) throws UnsupportedEncodingException {
		String s1 = "Xyz123";
		String s2 = "手可摘星辰";
		byte[] bys1 = s1.getBytes();
		byte[] bys2 = s2.getBytes();
		System.out.println(Arrays.toString(bys1));
		System.out.println(Arrays.toString(bys2));
	}
}
/*  GBK编码字符集下：
	[88, 121, 122, 49, 50, 51]
	[-54, -42, -65, -55, -43, -86, -48, -57, -77, -67]
 * */

6.3 IO操作时定义一个字节数组作为缓存

 public class CopyFileDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("c:\\a.txt");
		FileOutputStream fos = new FileOutputStream("d:\\b.txt");
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			fos.write(bys, 0, len);
		}
		fos.close();
		fis.close();
	}
}

6.5 通过带有缓冲区的字节类【高效类】

写数据：BufferedOutputStream
读数据：BufferedInputStream
看源码:
BufferedOutputStream 继承【过滤流】 FilterOutputStream。进一步地重写过滤流方法中的一些方法，并且还可以提供一些额外的方法和字段。
FilterOutputStream继承自抽象类OutputStream，过滤类本身只是简单地重写那些将所有请求传递给所包含输出流的 OutputStream 的所有方法。
实际上把缓冲写在包装在类中，BufferedInputStream原理类似。
通过定义数组的方式比一次读取一个字节的方式快很多，拥有缓冲区效率提升很多。
Java在设计时提供缓冲区的字节类BufferedOutputStream和BufferedInputStream。
真正的底层读写数据还是依靠基本流对象来实现，见源码解析。
【BufferedOutputStream】源代码解析

public class BufferedOutputStream extends FilterOutputStream {

    protected byte buf[];	//内部缓冲区
    protected int count;    //缓冲区存储的字节个数
    public BufferedOutputStream(OutputStream out) {
        this(out, 8192);
    }

    public BufferedOutputStream(OutputStream out, int size) {
        super(out);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size];//开辟一个缓冲区
    }

	//刷新内部缓冲区
    private void flushBuffer() throws IOException {
        if (count > 0) {
            out.write(buf, 0, count);
            count = 0;
        }
    }
	//将指定的字节写入此缓冲的输出流
    public synchronized void write(int b) throws IOException {
        if (count >= buf.length) {
            flushBuffer();
        }
        buf[count++] = (byte)b;
    }
	//将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
    public synchronized void write(byte b[], int off, int len) throws IOException {
        if (len >= buf.length) {
            flushBuffer();
            out.write(b, off, len);
            return;
        }
        if (len > buf.length - count) {
            flushBuffer();
        }
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }

    public synchronized void flush() throws IOException {
        flushBuffer();
        out.flush();
    }
}

6.7 比较4中IO复制操作的效率

/*
 * 需求：把F:\\红玫瑰.mp3【9.25M】复制到当前项目目录下的copy.mp4中
 */
public class CopyMp4Demo {
	public static void main(String[] args) throws IOException {
		long start = System.currentTimeMillis();
		method4("F:\\红玫瑰.mp3", "copy.mp3");
		long end = System.currentTimeMillis();
		System.out.println("共耗时：" + (end - start) + "毫秒");
	}
	
	//1、基本字节流一次读写一个字节
	public static void method1(String srcString, String destString)throws IOException {		
		FileInputStream fis = new FileInputStream(srcString);
		FileOutputStream fos = new FileOutputStream(destString);
		int by = 0;
		while ((by = fis.read()) != -1) {
			fos.write(by);
		}
		fos.close();
		fis.close();
	}
	//2、基本字节流一次读写一个字节数组
	public static void method2(String srcString, String destString)throws IOException {		
		FileInputStream fis = new FileInputStream(srcString);
		FileOutputStream fos = new FileOutputStream(destString);
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			fos.write(bys, 0, len);
		}
		fos.close();
		fis.close();
	}
	//3、高效字节流一次读写一个字节：
	public static void method3(String srcString, String destString)throws IOException {	
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));			
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString));				
		int by = 0;
		while ((by = bis.read()) != -1) {
			bos.write(by);
		}
		bos.close();
		bis.close();
	}	

	//4、高效字节流一次读写一个字节数组：
	public static void method4(String srcString, String destString)throws IOException {		
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));		
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString));	
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = bis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}
		bos.close();
		bis.close();
	}
}
/*
* 字节流4种方式复制文件所耗费的时间：
* 	method1基本字节流一次读写一个字节：	 共耗时：115906毫秒
* 	method2基本字节流一次读写一个字节数组：共耗时：342毫秒
* 	method3高效字节流一次读写一个字节：        共耗时：550毫秒
* 	method4高效字节流一次读写一个字节数组：共耗时：61毫秒
**/

7、IO流字符集可能出现的乱码

/*
 * 字节流读取中文可能出现的乱码问题：
 * a.txt文件的具体内容
 * 手可摘星辰
 * 2017.01.18.Java
 */
public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("a.txt");		
		/*//读取数据，英文正常，中文乱码异常。【此方案仅对单字节字符有效】
		int by = 0;
		while ((by = fis.read()) != -1) {
		 System.out.print((char) by);
		} */
		/*运行结果：??????????
			2017.01.18.Java	*/	 
		//解决：采用系统默认的编码字符集 
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			System.out.print(new String(bys, 0, len));
		}
		fis.close();		
		/* 手可摘星辰
		 * 2017.01.18.Java*/
	}
}

关于字符串的编解码说明

/*
 * 乱码产生原因：编解码采用不同方案所致。
 * 解决方案：编解码采用同一套字符集。
 * 编码：byte[] -- String : new String(byte[] bytes, String CharsetName )
 * 解码：String -- byte[] : getBytes(String CharsetName);
 * */
public class StringDemo {
	public static void main(String[] args) throws UnsupportedEncodingException {
		String s = "中国";
		byte[] bys1 = s.getBytes(); 
		byte[] bys2 = s.getBytes("GBK");
		byte[] bys3 = s.getBytes("UTF-8");
		System.out.println(Arrays.toString(bys1));
		System.out.println(Arrays.toString(bys2));
		System.out.println(Arrays.toString(bys3));
		
		String s1 = new String(bys1); 
		String s2 = new String(bys2, "GBK"); 
		String s3 = new String(bys3, "UTF-8"); 
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
	}
}
/*  运行结果：
	[-42, -48, -71, -6]
	[-42, -48, -71, -6]
	[-28, -72, -83, -27, -101, -67]
	中国
	中国
	中国
 * *