整理 JAVA中的IO流 (字符流和字节流两个大类）

java中的io流分为两类，字符和字节：

• OutputStream和InputStream字节流的父类，抽象。OutputStream有两个提供了实现的接口closable和flushable。
• Writer和Reader字符流的父类，抽象。
  实际上在流的操作中，底层与文件进行读写的都是字节流，因为即使是字符流的对象，其最终实现读写的也是用的字节流。

1. 操作文件的字节子类FileOutputStream和FileInputStream。
   记住，这里面写出和读入的都是字节。

class  useByteStream
{
       /**
        * 使用文件输出字节流
        *
        */
       public static void testFileOutputStream()
       {
              OutputStream out = null;
              try
              {
                     File f = new File(".//log//test.txt");
                     //out = new FileOutputStream(f);
                     out = new FileOutputStream(f,true); //追加方式记录到文件
                     String str = "Hello World!!!";
                     byte b[] = str.getBytes();
                     out.write(b);
                     out.close();
              }
              catch(FileNotFoundException e)
              {

              }
              catch(IOException e)
              {

              }
       }

       /**
        * 使用文件输入字节流
        */
       public static void testFileInputStream()
       {
              InputStream out = null;
              try
              {
                     File f = new File(".//log//test.txt");
                     out = new FileInputStream(f);
                     String str = "Hello World!!!";
                     byte b[] = new byte[1000];
                     int len = out.read(b);
                     System.out.println(new String(b,0, len) );
                     out.close();
              }
              catch(FileNotFoundException e)
              {

              }
              catch(IOException e)
              {

              }
       }
};

2. 操作文件的字符子类FileWriter和FileReader

class useCharStream
{
       /**
        * 使用文件字符输出流
        */
       public static void testFileWriter()
       {
              Writer w = null;
              try
              {
                     File f = new File(".//log//test2.txt");
                     w = new FileWriter(f,true); //追加方式
                     w.write("hello world/r/n");
                     w.close();
              }
              catch(FileNotFoundException e)
              {
                     e.printStackTrace();
              }
              catch(IOException e)
              {
                     e.printStackTrace();
              }

       }

       /**
        * 使用文件字符输入流
        */
       public static void testFileReader()
       {
              Reader w = null;
              try
              {
                     File f = new File(".//log//test2.txt");
                     w = new FileReader(f);
                     char c[] = new char[1024];
                     w.read(c);
                     System.out.println(c);
                     w.close();
              }
              catch(FileNotFoundException e)
              {
                     e.printStackTrace();
              }
              catch(IOException e)
              {
                     e.printStackTrace();
              }
       }

};

3. 两个转换类，OutputStreamWriter，负责将写入字符流转为字节流，InputStreamReader，负责读取字节流转为字符流。
   FileWriter的直接父类是OutputStreamWriter，并非Writer。
   FileReader的直接父类是InputStreamReader，并非Reader。
   因此，最终写入文件和从文件读出的都是字节流。

   以上都是基于文件流操作，接下来是基于内存操作流，如果只是写业务代码应该很少会用到。

4. 内存操作流
   ByteArrayInputStream/ByteArrayOutputStream。

class useMemoryStream
{
       /**
        * 使用内存操作流,字节
        */
       public static void testByteArray()
       {
              String str = "Hello world";
              ByteArrayInputStream bis = null;
              ByteArrayOutputStream bos = null;

              bis = new ByteArrayInputStream(str.getBytes());
              bos = new ByteArrayOutputStream();
              int temp =0;
              while((temp=bis.read())!=-1)
              {
                     char c = (char)temp;
                     bos.write(Character.toUpperCase(c));
              }
              String newStr = bos.toString();
              try
              {
                     bis.close();
                     bos.close();
              }
              catch(IOException e)
              {
                     e.printStackTrace();
              }
              System.out.println(newStr);
       }
};

5. 另外，管道流可以实现两个线程之间的通信。
   PipedInputStream 和 PipedOutputStream。
   PipedOutputStream通过connect方法与PipedInputStream建立连接，后续PipedOutputStream.write的内容，就会PipedInputStream.read方法读取

class Send implements Runnable
{
       private PipedOutputStream pos  = null;
       public Send()
       {
              this.pos = new PipedOutputStream();
       }
       public void run()
       {
              String str = "Hello world!!!";
              try
              {
                     try
                     {
                           Thread.sleep(2000);
                     }
                     catch(InterruptedException e)
                     {
                           e.printStackTrace();
                     }
                     this.pos.write(str.getBytes());
                     System.out.println("thread:"+Thread.currentThread().getId()+",Send  string:"+str);

              }
              catch(IOException e)
              {
                     e.printStackTrace();
              }

              try
              {
                     this.pos.close();
              }
              catch(IOException e)
              {
                     e.printStackTrace();
              }
       }
       public PipedOutputStream getPos()
       {
              return this.pos;
       }
};
class Receive implements Runnable
{
       private PipedInputStream pis = null;
       public Receive()
       {
              this.pis = new PipedInputStream();
       }
       public void run()
       {
              byte b[] = new byte[1024];
              int len =0;
              try
              {
                     len = this.pis.read(b); //阻塞方式

              }
              catch(IOException e)
              {
                     e.printStackTrace();
              }
              try
              {
                     pis.close();
              }
              catch(IOException e)
              {
                     e.printStackTrace();
              }
              System.out.println("thread:"+Thread.currentThread().getId()+",receive:"+new  String(b,0,len));

       }

       public PipedInputStream getPis()
       {
              return this.pis;
       }
};
class pipedTest
{
       public void pipedStream()
       {
              Send s = new Send();
              Receive r = new Receive();
              try {
                     s.getPos().connect(r.getPis());
              }
              catch(IOException e)
              {
                     e.printStackTrace();
              }

              new Thread(r).start();

              new Thread(s).start();

       }
};

以上都是无缓存的，考虑到一般场景下，提高使用性能，最好使用有缓存的字符流：BufferedReader和BufferedWriter。

6. BufferedReader
   只能接受输入为字符流，不能为字节流。所以有时候会使用InputStreamReader来转换字节流给字符流使用。还有BufferedWriter

   class useBuffer
   {
      public static void testBufferReader()
      {
             BufferedReader buf = null;
             //此处用到了字节流转字符流的类InputStreamReader，这是因为BufferedReader只能接收字符流
             buf = new BufferedReader(new InputStreamReader(System.in));
             String str =null;
             try
             {
                    str = buf.readLine();
             }
             catch(IOException e)
             {
                    e.printStackTrace();
             }
             System.out.println("输出的内容为："+str);
   
      }
      public static void testBufferWriter()
      {
             File f = new File(".//log//test2.txt");
             try {
                   //默认缓冲区大小 8K   可以通过 new BufferedWriter(new FileWriter(f),1024);指定大小为1K
                    BufferedWriter out =new BufferedWriter(new FileWriter(f));
                    out.write("123321123355555", 0, 10);
                     out.write("/r/n");
                     out.close();
             } catch (IOException e) {
                    e.printStackTrace();
             }
      }
   };

7. SCanner类，输入数据类。
   使用方法和BufferedReader类类似，并且方便验证数据类型。

   class useScan
   {
      public static void testScan()
      {
             Scanner scan = new Scanner(System.in);
             //以回车作为输入的结束符号，否则默认是空格
             scan.useDelimiter("/r/n");
             if(scan.hasNextInt()==true)
             {
                    int str = scan.nextInt();
                    System.out.println("int "+str);
             }
             else
             {
                    String str = scan.next();
                    System.out.println("string "+str);
             }
   
      }
   };

   scan.hasNext支持正则表达式。比如 hasNext("^//d{4}-//d{2}-//d{2}$") 就是日期格式yyyy-MM-dd的正则表达式，通过next("^//d{4}-//d{2}-//d{2}$")。