黑马程序员——JAVA学习日志之IO流（一）

------- android培训、java培训、期待与您交流！ ----------

学习日志之IO流

IO流概述及其分类

     IO流用来处理设备之间的数据传输

     Java对数据的操作是通过流的方式

     Java用于操作流的类都在IO包中

     流按流向分为两种：输入流，输出流。

IO程序书写

     使用前，导入IO包中的类

     使用时，进行IO异常处理。IO流的操作是非常容易出异常的，异常主要包括文件路径不存在。

     使用后，释放资源（一定不要忘了）

 

FileInputStream

      read()一次读取一个字节

FileInputStream fis = new FileInputStream("aaa.txt");	//创建一个文件输入流对象,并关联aaa.txt
		int b;					//定义变量,记录每次读到的字节
		while((b = fis.read()) != -1) {		//将每次读到的字节赋值给b并判断是否是-1
			System.out.println(b);		//打印每一个字节
		}
		
		fis.close();				//关闭流释放资源

思考： read()方法读取的是一个字节,为什么返回是int,而不是byte？

      因为字节输入流可以操作任意类型的文件,比如图片音频等,这些文件底层都是以二进制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到111111111

      那么这11111111是byte类型的-1,我们的程序是遇到-1就会停止不读了,后面的数据就读不到了,所以在读取的时候用int类型接收,如果11111111会在其前面补上

      24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完,而结束标记的-1就是int类型

FileOutputStream

      write()一次写出一个字节

      write(int b)会自动将int类型的参数前面的24个0 自动去掉。

FileOutputStream fos = new FileOutputStream("bbb.txt");	//如果没有bbb.txt,会创建出一个
		//fos.write(97);		//虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte
		fos.write(98);
		fos.write(99);
		fos.close();

FileOutputStream追加

        FileOutputStream(String pathname)的构造方法会在将文件清空，再写入数据。

        要想在文件的末尾追加写入数据的话，应该在构造方法上添加第二个参数true：FileOutputStream("xxx.xxx",true)

FileOutputStream fos = new FileOutputStream("bbb.txt",true);	//如果没有bbb.txt,会创建出一个
		//fos.write(97);				//虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte
		fos.write(98);
		fos.write(99);
		fos.close();

拷贝文件

      用FileInputStream读出。 FileOutputStream写入

模板代码。IO流绝大部分功能都是由如下代码略作修改得到的。

FileInputStream fis = new FileInputStream("致青春.mp3");	         //创建输入流对象,关联致青春.mp3
		FileOutputStream fos = new FileOutputStream("copy.mp3"); //创建输出流对象,关联copy.mp3
		
		int b;
		while((b = fis.read()) != -1) {
			fos.write(b);
		}
		
		fis.close();
		fos.close();

字节流一次读写一个字节复制音频。

弊端:效率太低。如果拷贝的是几百兆的压缩包就有的等了。

字节数组拷贝之available()方法

         int read(byte[] b):一次读取一个字节数组。注意，当参数是byte[]时，read（）方法的返回值就不是读入的字节转码了，而是读取的字节数量，或当读到文件末尾时返回-1

         write(byte[] b):一次写出一个字节数组

         available()获取读的文件所有的字节个数

FileInputStream fis = new FileInputStream("致青春.mp3");
		FileOutputStream fos = new FileOutputStream("copy.mp3");
		byte[] arr = new byte[fis.available()];					//根据文件大小做一个字节数组
		fis.read(arr);								//将文件上的所有字节读取到数组中
		fos.write(arr);								//将数组中的所有字节一次写到了文件上
		fis.close();
		fos.close();

弊端:当拷贝的文件过大时，有可能会内存溢出

定义小数组

        可以用小数组的方式解决文件过大的弊端。

        write(byte[] b)：写入字节数组

        write(byte[] b, int off, int len)：写入字节数组的部分，int off 代表着要写入部分的开始索引，int len代表要写入字节的个数

        因为要拷贝的文件的总字节数未必能被数组的长度整除。当拷贝到最后一组数据时，字节数是小于数组长度的。而数组多余的部分还存着上一次拷贝的参与数据。所以这部分不可以被拷贝。

定义小数组的标准格式：

        字节流一次读写一个字节数组复制图片和视频：

FileInputStream fis = new FileInputStream("致青春.mp3");
		FileOutputStream fos = new FileOutputStream("copy.mp3");
		int len;
		byte[] arr = new byte[1024   8];					//自定义字节数组
		
		while((len = fis.read(arr)) != -1) {
			//fos.write(arr);
			fos.write(arr, 0, len);						//写出字节数组写出有效个字节个数
		}
		
		fis.close();
		fos.close();

BufferedInputStream和BufferOutputStream拷贝

        对小数组拷贝的优化的拷贝方式。

       缓冲思想

               字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，

               这是加入了数组这样的缓冲区效果，java本身在设计的时候，

               也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流

BufferedInputStream

         BufferedInputStream内置了一个缓冲区(数组)

         从BufferedInputStream中读取一个字节时

         BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个

         程序再次读取时, 就不用找文件了, 直接从缓冲区中获取

         直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个

  BufferedOutputStream

         BufferedOutputStream也内置了一个缓冲区(数组)

         程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中

         直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里

  拷贝的代码

FileInputStream fis = new FileInputStream("致青春.mp3");			        //创建文件输入流对象,关联致青春.mp3
		BufferedInputStream bis = new BufferedInputStream(fis);			//创建缓冲区对fis装饰
		FileOutputStream fos = new FileOutputStream("copy.mp3");		//创建输出流对象,关联copy.mp3
		BufferedOutputStream bos = new BufferedOutputStream(fos);		//创建缓冲区对fos装饰
		
		int b;
		while((b = bis.read()) != -1) {		
			bos.write(b);
		}
		
		bis.close();						                //只关装饰后的对象即可
		bos.close();

小数组的读写和带Buffered的读取哪个更快?

         定义小数组如果是8192个字节大小和Buffered比较的话

         定义小数组会快很多,因为读和写操作的是同一个数组

         而Buffered操作的是两个数组

         本人实测，当拷贝一个600M大小的压缩包是，小数组耗时2秒，缓冲区耗时30秒。差了很多。

不过，过于频繁的对硬盘进行读写，很不稳定，容易出错。也对硬件有一定伤害。

flush和close方法的区别

  flush()方法

         用来刷新缓冲区的,刷新后可以再次写出

  close()方法

         用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出

如果拷贝结束后，没有关闭输出流的话，拷贝的目标文件会别源文件小一点，会有数据损坏。是输出流写入的最后一批数据必须刷新一次才能被成功写入。

流的标准处理异常代码

因为IO流设计了底层实现。所以异常不可try catch自己偷偷处理掉。但是如果直接throws的换，如果运行时发生异常，IO流就无法正常关闭了。所以要用try finally句式，在finally语句里将IO流关掉。

1.6版本及其以前

两个finally嵌套是因为防止在finally里发生异常的话，至少能关掉一个。

  tryfinally嵌套

<span style="white-space:pre">		</span>FileInputStream fis = null;//不加null的话，后面的关闭IO的代码就没法逻辑判断了。系统也会报异常。
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("aaa.txt");
			fos = new FileOutputStream("bbb.txt");
			int b;
			while((b = fis.read()) != -1) {
				fos.write(b);
			}
		} finally { //两个finally嵌套是因为防止在finally里发生异常的话，至少能关掉一个。                                  
			try {
				if(fis != null)
					fis.close();
			}finally {
				if(fos != null)
					fos.close();
			}
		}

流的标准处理异常代码1.7版本

		try(
			FileInputStream fis = new FileInputStream("aaa.txt");
			FileOutputStream fos = new FileOutputStream("bbb.txt");
			MyClose mc = new MyClose();
		){
			int b;
			while((b = fis.read()) != -1) {
				fos.write(b);
			}
		}

原理

         在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉