I/O流——字节流

流的概念

流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以使文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。

流的分类

①   流按其流向分为“输入流”和“输出流”。

②   流按数据传输单位分为“字节流”和“字符流”。

a)         “字节流”用来读写8位二进制的字节。

b)         “字符流”用来读写16位二进制字符。

③   流按功能分为“节点流”和“过滤流”。

a)         “节点流”用于直接操作目标设备的流。例如：磁盘或一块内存区域。

b)         “过滤流”是对一个已存在的流的链接和封装，通过对数据进行处理为程序提供功能强大、灵活的读写功能。

字节流

字节流类用于向字节流读取8位二进制的字节。一般地，字节流主要用于读写诸如图像或声音等二进制数据。

字节流类以InputStream和OutputStream为顶层类。它们都是抽象类。

一、InputStream

①     InputStream是定义了字节输入流的抽象类。

②     InputStream中定义的方法

a)         public abstract int read()

b)         public int read(byte[] b)

c)         public int read(byte[] b,int off,int len)

d)         public long skip(long n)

e)         public int available()

f)          public void close()

二、OutputStream

① OutputStream是定义了字节输出流的抽象类。

② 该类所有方法返回void值，在出错情况下抛IOException异常

③ OutputStream中定义的方法

g)         public abstract void write(int b)

h)         public void write(byte[] b)

i)           public void write(byte[] b,int off,int len)

j)           public void flush()

k)         public void close()

每个抽象类都有多个具体的子类，这些子类对不同的外设进行处理，例如磁盘文件，网络连接，甚至是内存缓冲区。

三、FileInputStream

① FileInputStream类表示能从文件读取字节的InputStream类

② 构造方法

a)         FileInputStream(String filePath)

b)         FileInputStream(File fileObj)

四、FileOutputStream

① FileOutputStream表示能向文件写入字节的OutputStream类

② 构造方法

a)         FileOutputStream(String filePath)

b)         FileOutputStream(File fileObj)

c)         FileOutputStream(String filePath,boolean append)

示例：拷贝指定文件到指定目录

 class FileCopyUtil {
     public static void copyFile(File src, File dst) throws IOException {
         FileInputStream fis = new FileInputStream(src);
         FileOutputStream fos = new FileOutputStream(dst);
         long time1 = System.currentTimeMillis();
         int data = -1;
         while ((data = fis.read()) != -1) {
             fos.write(data);
         }
         fis.close();
         fos.close();
         long time2 = System.currentTimeMillis();
         System.out.println("复制完成，共花费：" + (time2 - time1) + "毫秒");
     }
 }

主方法：

         try {
             FileCopyUtil.copyFile(new File("d:/zhangsan/tu.png"), new File("e:/fuzhi.png"));
         } catch (IOException e) {
             e.printStackTrace();
         }

输出结果

复制完成，共花费：1545毫秒

单一张71K的图片就花费了1545毫秒，由此可见效率是极低的，因为它是读一个写一个，我们可以换种思路，先全部读到一个缓冲区，再将内容一次性写入。这里就好比喝水时一滴一滴地喝还是接到杯子里再喝。

改造下方法，如下：

 class FileCopyUtil {
     public static void copyFile(File src, File dst) throws IOException {
         FileInputStream fis = new FileInputStream(src);
         FileOutputStream fos = new FileOutputStream(dst);
         byte[] buff = new byte[1024 * 1024];// 创建一个1M大小的缓冲区，用来存放输入流中的字节
         int len = 0;// 用来保存实际读到的字节数
         long time1 = System.currentTimeMillis();
         while ((len = fis.read(buff)) != -1) {
             fos.write(buff, 0, len);
         }
         fis.close();
         fos.close();
         long time2 = System.currentTimeMillis();
         System.out.println("复制完成，共花费：" + (time2 - time1) + "毫秒");
     }
 }

同样读取那张图片，输出结果：

复制完成，共花费：3毫秒

再复制一个8M的mp3格式文件，输出结果：

复制完成，共花费：39毫秒

五、ByteArrayInputStream

①ByteArrayInputStream是把字节数组当成源的输入流。

②两个构造方法，每个都需要一个字节数组提供数据源：

a)       ByteArrayInputStream(byte array[])

b)       ByteArrayInputStream(byte array[],int start,int numBytes)

         String str="hello,HangZhou";
         ByteArrayInputStream bis=new ByteArrayInputStream(str.getBytes());
         int data=-1;
         while((data=bis.read())!=-1)
         {
             System.out.println((char)data);
         }

输出结果：

h e l l o , H a n g Z h o u

六、ByteArrayOutputStream

①ByteArrayOutputStream是把字节数组当作目标的输出流。

②两个构造方法：

a)       ByteArrayOutputStream()

创建一个新的byte数组输出流

b)       ByteArrayOutputStream(int numBytes)

创建一个新的byte数组输出流，具有指定大小缓冲区（字节为单位）

         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         bos.write(97);
         bos.write(65);
         try {
             bos.write("hello,word".getBytes());
         } catch (IOException e) {
             e.printStackTrace();
         }
         byte[] buff = bos.toByteArray();
         for (byte b : buff) {
             System.out.print((char)data+" ");
         }

         FileOutputStream fos=new FileOutputStream("d://aa.txt", true);
         bos.writeTo(fos);//把ByteArrayOutputStream内部缓冲区的数据写到对应的文件输出流中
         fos.close();

输出结果:

aAhello,word

并会在d盘下创建一个aa.txt文件，里面内容为输出结果的内容，再次执行将追加一次执行结果的内容。

过滤流

① 过滤流仅仅是为底层透明地提供扩展功能的输入流（输出流）的包装。这些流一般由普通类的方法（即过滤流的一个父类）访问。

② 过滤字节流FilterInputStream和FilterOutputStream。构造方法：

a)　　FilterInputStream(InputStream is)

b)　　FilterOutputStream(OutputStream os)

③ 这些类提供的方法和InputStream及OutputStream类的方法相同。

④ 常用的过滤流BufferedInputStream和BufferedOutputStream,DataInputStream和DataOutputStream

BufferedInputStream，BufferedOutputStream用法举例

使用过滤流来改写上面的复制方法

 class FileUtil {
     public static void copyFile(File src, File dst) throws IOException {
         FileInputStream fis = new FileInputStream(src);
         FileOutputStream fos = new FileOutputStream(dst);
         BufferedInputStream bis=new BufferedInputStream(fis);
         BufferedOutputStream bos=new BufferedOutputStream(fos);

         int data = 0;// 用来保存实际读到的字节数
         long time1 = System.currentTimeMillis();
         while ((data = bis.read()) != -1) {
             bos.write(data);
         }
         bis.close();
         bos.close();
         long time2 = System.currentTimeMillis();
         System.out.println("复制完成，共花费：" + (time2 - time1) + "毫秒");
     }
 }

主方法：

         try {
             FileUtil.copyFile(new File("d:/zhangsan/Closer To Me.mp3"), new File(
                     "e:/fuzhi.mp3"));
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

复制同样的一首歌，输出结果：

复制完成，共花费：905毫秒

时间增加了很多，但也比文件直接读写快了不少。Buffered中自带一个8k左右的缓冲区。

DataInputStream和DataOutputStream用法举例：

写入文件：

         String name="zhangsan";
         int age=10;
         boolean flag=true;
         char sex='男';
         double money=123.45;

         DataOutputStream dos=new DataOutputStream(new FileOutputStream("d:/b.txt"));
         dos.writeUTF(name);
         dos.writeInt(age);
         dos.writeBoolean(flag);
         dos.writeChar(sex);
         dos.writeDouble(money);
         dos.close();

打开b.txt后发现有乱码，那是因为写进去的是二进制

读文件:

         DataInputStream dis=new DataInputStream(new FileInputStream("d:/b.txt"));
         //读的顺序必须与写入的顺序一致
         System.out.println(dis.readUTF());
         System.out.println(dis.readInt());
         System.out.println(dis.readBoolean());
         System.out.println(dis.readChar());
         System.out.println(dis.readDouble());
         dis.close();

输出结果：

zhangsan

10

true

男

123.45

过滤流总结：

BufferedInputStream与BufferedOutputStream

需要使用已经存在的节点流来构造，提供缓冲的读写，提高了读写的效率。

DataInputStream与DataOutputStream

数据输入输出流允许应用程序读写基本Java数据类型。应用程序可以使用数据输出流写入，稍后由数据输入流读取。读写顺序要保持一致。