IO流之FileInputStream与FileOutputStream

一、FileInputStream

1，read()一次读取一个字节

     Java Code  
  

1
2
3
4
5
6

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

二、FileOutputStream

1，write()一次写出一个字节

     Java Code  
  

1
2
3
4
5

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

2，追加

     Java Code  
  

1
2
3
4
5

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

三、BufferedInputStream和BufferOutputStream缓冲

1，缓冲思想

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想，所以提供了字节缓冲区流。

2、BufferedInputStream

* BufferedInputStream内置了一个缓冲区(数组)
* 从BufferedInputStream中读取一个字节时
* BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个
* 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取

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

3、BufferedOutputStream

* BufferedOutputStream也内置了一个缓冲区(数组)
* 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中

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

4、BufferedInputStream和BufferOutputStream使用示例

     Java Code  
  

1
2
3
4
5
6
7
8
9
10
11
12

FileInputStream fis = new FileInputStream( "bbb.mp3" );            //创建文件输入流对象,关联bbb.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();

四、示例

1，拷贝图片

     Java Code  
  

1
2
3
4
5
6
7
8

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

2，定义小数组拷贝

     Java Code  
  

1
2
3
4
5
6
7
8
9

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, 0 , len);                          //写出字节数组写出有效个字节个数
        }
        fis.close();
        fos.close();

3，内存输出流示例

* 定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

     Java Code  
  

1
2
3
4
5
6
7
8
9

FileInputStream fis = new FileInputStream( "a.txt" );              //创建字节输入流,关联a.txt
            ByteArrayOutputStream baos = new ByteArrayOutputStream();        //创建内存输出流
             byte [] arr = new byte [ 5 ];                                        //创建字节数组,大小为5
             int len;
             while ((len = fis.read(arr)) != - 1 ) {                             //将文件上的数据读到字节数组中
                baos.write(arr, 0 , len);                                     //将字节数组的数据写到内存缓冲区中
            }
            System.out.println(baos);                                        //将内存缓冲区的内容转换为字符串打印
            fis.close();

五、其他

1、flush和close方法的区别

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

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

     Java Code  
  

1
2
3
4
5
6
7
8
9
10

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);
            }
        }

3、字节流读写中文

* 字节流读取中文的问题
* 字节流在读中文的时候有可能会读到半个中文,造成乱码
* 字节流写出中文的问题
* 字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
* 写出回车换行 write("\r\n".getBytes());

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

* 定义小数组如果是8192个字节大小和Buffered比较的话
* 定义小数组会略胜一筹,因为读和写操作的是同一个数组

* 而Buffered操作的是两个数组

5、内存输出流

1，什么是内存输出流

* 该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据

2，使用方式

* 创建对象: new ByteArrayOutputStream()
* 写出数据: write(int), write(byte[])

* 获取数据: toByteArray()

     Java Code  
  

1
2
3
4
5
6
7
8
9
10
11

FileInputStream fis = new FileInputStream( "a.txt" );
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
             int b;
             while ((b = fis.read()) != - 1 ) {
                baos.write(b);
            }

             //byte[] newArr = baos.toByteArray();               //将内存缓冲区中所有的字节存储在newArr中
             //System.out.println(new String(newArr));
            System.out.println(baos);
            fis.close();