在之前的博客中，当介绍某个类的时候，我会将类的构造方法以及方法摘要通过表格展示出来，这些内容在JDKAPI上面都可以找到，所以从这一篇博客开始，这些方法将不再全部列出，会从中抽取一部分常用的方法。
言归正传，在上一篇博客《JAVA输入输出（IO）之文件》中介绍了File类的简单使用，如果我们要对文件进行读取、写入，仅有一个File是远远不够的，这一篇为大家介绍字节流的概念，通过本片博客，我们可以实现文件读取、写入、复制等。当然了输入输出流不仅仅可以用在文件的读写上面，还可以用于网络通信、进程通信等。

字节输入流

java.io.InputStream类是表示字节输入流的所有类的超类，字节输入流都直接或间接的继承了该类，通常情况下我们会使用该类的子孙类操作字节输入流，实现对字节输入流的读取。
在该类中，我们最常用的方法有如下几个：

返回值	方法名	说明
void	close()	关闭此输入流并释放与该流关联的所有系统资源
abstract int	read()	从输入流中读取数据的下一个字节
int	read(byte[] b)	从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len)	将输入流中最多 len 个数据字节读入 byte 数组

对于很多初学者而言，有时候比较纠结的是什么时候用输入流，什么时候用输出流。其实这个是很简单的，我们只需要搞清楚数据的流向就可以了，如果数据是流向内存的，就是输入流，由内存流出的就是输出流。

由于输入流的实现类也很多，这里使用文件输入流（java.io.FileInputStream）作为例子为大家介绍，其他的输入流基本上是大同小异，可以自己尝试着使用。需要注意的是，不管是输入流还是输出流，在使用完毕后要调用相应的关闭方法释放流资源，且关闭资源时遵循先开后闭的原则。

直接上例子：

import java.io.FileInputStream;
import java.io.IOException;

public class FileReadWrite
{
   public static void main(String[] args)
   {
      FileInputStream stream = null;
      try
      {
         // 选用指定文件路径的构造方法
         //test.txt文件内容为：111111111112121112211212
         stream = new FileInputStream("test.txt");
         int data = -1;
         // 从此输入流中读取一个数据字节，如果已到达文件末尾，则返回 -1
         while ((data = stream.read()) != -1)
         {
            // 准备的文件为文本文件，且内容为阿拉伯数字，所以直接强制转换为字符输出
            System.out.print((char) data);
         }
      }
      catch (IOException e)
      {
         //异常处理
      }
      finally
      {
         try
         {
            if (stream != null)
            {
               // 关闭输入流
               stream.close();
            }
         }
         catch (IOException e)
         {
         }
      }
   }
}

运行结果为：
111111111112121112211212

使用read()方法的效率是很低的，在实际开发中，我们会经常使用read(byte[] b)，另外JAVA输入流还提供了缓冲流。java.io.BufferedInputStream就是字节输入缓冲流。BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。mark 操作记录输入流中的某个点，reset 操作使得在从包含的输入流中获取新字节之前，再次读取自最后一次 mark 操作后读取的所有字节。

字节输出流

上面介绍了JAVA的字节输入流，那么相反的就会有字节输出流。java.io.OutputStream类是表示输出字节流的所有类的超类。

在该类中，我们最常用的方法有如下几个：

返回值	方法名	说明
void	close()	关闭此输出流并释放与此流有关的所有系统资源
void	flush()	刷新此输出流并强制写出所有缓冲的输出字节
void	write(byte[] b)	将 b.length 个字节从指定的 byte 数组写入此输出流
void	write(byte[] b, int off, int len)	将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
abstract void	write(int b)	将指定的字节写入此输出流

输出流接受输出字节并将这些字节发送到某个接收器。与FileInputStream对应的有java.io.FileOutputStream类。下面我们就以FileOutputStream演示向文件中写入数据。

import java.io.FileOutputStream;
import java.io.IOException;

public class FileReadWrite
{
   public static void main(String[] args)
   {
      FileOutputStream stream = null;
      try
      {
         stream = new FileOutputStream("test.txt");
         // 向输出流中写入数据
         stream.write("11111".getBytes());
         // 刷新此输出流并强制写出所有缓冲的输出字节
         stream.flush();
      }
      catch (IOException e)
      {
         e.printStackTrace();
      }
      finally
      {
         try
         {
            // 关闭
            if (stream != null)
            {
               stream.close();
            }
         }
         catch (IOException e)
         {
         }
      }
   }
}

使用示例

现在我们将输入流和输出流整合在一起，完成文件的复制。

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

public class FileReadWrite
{
   /**
    * 复制文件
    * 
    * @param src
    *           源文件
    * @param desc
    *           目标文件
    * @return
    */
   public boolean copy(String src, String desc)
   {
      FileInputStream inputStream = null;
      FileOutputStream outputStream = null;
      try
      {
         inputStream = new FileInputStream(src);
         outputStream = new FileOutputStream(desc);
         int len = -1;
         byte[] buffer = new byte[512];
         // 循环读取，直至文件结束
         while ((len = inputStream.read(buffer)) != -1)
         {
            outputStream.write(buffer, 0, len);
         }
         outputStream.flush();
      }
      catch (IOException e)
      {
         e.printStackTrace();
         return false;
      }
      finally
      {
         try
         {
            // 关闭
            if (inputStream != null)
            {
               inputStream.close();
            }
         }
         catch (IOException e)
         {
         }
         try
         {
            // 关闭
            if (outputStream != null)
            {
               outputStream.close();
            }
         }
         catch (IOException e)
         {
         }
      }
      return true;
   }
}