IO

           1）概述

                1. java中用于操作流的对象都在IO包中

                2. 流按操作的数据分为：字节流和字符流。字符流只能处理文本，字节流任何都可以处理

                3. 流按流向可以分为输入流、输出流

                4. 字节流抽象基类：InputStream、OutputStream     

                    字符流抽象基类：Reader、Writer

                    由这4个基类派生的子类都是以基类作为类名后缀

           2） IO操作规律

                1. 先看是输入还是输出

                    输入：InputStream、Reader

                    输出： OutputStream、Writer

               2. 再看是否是纯文本

                   是：Reader、Writer

                   否：InputStream、OutputStream

               3. 再看源和目的的类型

                   源：文件、内存、键盘

                  目的：文件、内存、控制台

               4. 最后看是否可以使用装饰类来提高操作效率

              例子：从一个文本文件内容复制到另一个文件

                 1> 源

                      因为是输入，所以使用InputStream、Reader

                      因为是纯文本，所以使用Reader

                      因为是从文件读取，所以使用FileReader

                      在此处可以使用装饰类提高效率，所以使用BufferedReader

           File f = new File("test.txt");
           BufferedReader br = new BufferedReader(new FileReader(f));

                  2> 目的

                     因为是输出，所以使用OutputStream、Writer

                     因为是纯文本，所以使用Writer

                     因为操作对象时文件，所以使用FileWriter

                    在此处可以使用装饰类来提高效率，所以使用BufferedWriter

          File f = new File("test.txt");
          BufferedWriter bw = new BufferedWriter(new FileWriter(f));

          3） 输入字节流向输入字符流转换

                1. 转换原因：因为转换为字符流之后，就可以使用BufferedReader、BufferedWriter装饰，从而使用其中的readLine方法

                2.实例

         InputStream inputStream = System.in;
         InputStreamReader reader = new InputStreamReader(inputStream);
         BufferedReader bufferedReader = new BufferedReader(reader);

        简化BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

           4） 输出字节流向输出字符流转换

                 1.转换原因：可以设置编码

                 2.实例

          OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“asd.txt”)),  ”UTF-8”）

          5）读操作

                1. 使用InputStream或Reader的read()来读取单个字节（字符）

                    1>  因为返回的是int类型，所以如果读取的是字符，还需要进行强制转换

                    2> 如果读到文件末尾，返回的是-1

                    3> 实例

                FileReader fileReader = null;
		try
		{
			fileReader = new FileReader("mm.txt");
			int ch = 0;
			while((ch=fileReader.read()) != -1)
				System.out.println((char)ch);

               2. 使用InputStream或Reader的read(byte[])（或read(char[])）来读取流中内容到数组中

                   1> 一般设置数组的长度是1024的倍数

                   2> 此时read的返回值是读到的字节（或字符）数

                   3>读到文件末尾，返回的也是-1

            fileReader = new FileReader("mm.txt");

            char[] cbuf = new char[1024];
            int num;
            while((num=fileReader.read(cbuf)) != -1)
            {
                System.out.println(new String(cbuf,0,num));
            }

               3. 使用BufferedReader来提高读取效率

                   1> 特有方法：readLine，读取一行数据，如果没有则返回空

                   2>实例：

            FileReader fileReader = null;
            BufferedReader bufferedReader = null;
            try
            {
                fileReader = new FileReader("mm.txt");
                bufferedReader = new BufferedReader(fileReader);

                String line = null;
                while((line=bufferedReader.readLine()) != null)
                {
                   System.out.println(line);
                }

            } catch (IOException e)
             {
                e.printStackTrace();
             }
             finally
             {
                 try
                 {
                    if(bufferedReader != null)
                        bufferedReader.close();
                 } catch (IOException e)
		{
                    e.printStackTrace();
		}
             }

                   3>注意：关闭BufferedReader、BufferedWriter会连Reader、Writer对象一起关闭，所以只用关闭Buffered对象即可
          6）写操作

                1. 使用OutputStream或Writer的write()来写入单个字节（字符）

                    1>  因为传入的是int类型，所以如果写入的是字符，还需要进行强制转换

                    2> 实例

              File f = new File("e:"+File.separator+"test.txt");
              FileOutputStream fos = null;
              try {
                  fos = new FileOutputStream(f);
                  fos.write(58);
              }

               2. 使用OutputStream或Writer的write(byte[])（或write(char[])）来将数组中内容写入到流中

                   1> 一般设置数组的长度是1024的倍数

                   2> 实例

            File f = new File("e:"+File.separator+"test.txt");
            FileOutputStream fos = null;

            fos = new FileOutputStream(f);
            byte[] content = new byte[2048];
            fos.write(content);

               3. 使用BufferedWriter来提高写入效率

                   1> 特有方法：write(String str)，可以和BufferedReader的readLine方法配合使用

                   2>实例：

            FileWriter fileWriter = null;
            BufferedWriter bufferedWriter = null;
            try
            {
<pre name="code" class="java">                fileWriter = new FileWriter("mm.txt",true);

bufferedWriter = new BufferedWriter(fileWriter); bufferedWriter.write("hao gaoxing a"); }

                   3>注意：关闭BufferedReader、BufferedWriter会连Reader、Writer对象一起关闭，所以只用关闭Buffered对象即可

            4.注意：

               如果直接使用

        fileWriter = new FileWriter("mm.txt");

                表示如果文件里面有内容则会删除，然后再向文件里面写

              如果使用

        fileWriter = new FileWriter("mm.txt",true);

               表示如果文件中有内容，则在原来内容后面续写

         7）异常处理

                1. 因为肯定要执行close操作，所以推荐将close写在finally中，这样既可以保证流被关闭，又可以防止被关闭两次

                2. 因为close也可能会抛出异常，所以在finally中对close操作也要try、catch

                3.实例

            FileWriter fileWriter = null;
            BufferedWriter bufferedWriter = null;
            try
            {
                fileWriter = new FileWriter("mm.txt",true);
                bufferedWriter = new BufferedWriter(fileWriter);
                bufferedWriter.write("hao gaoxing a");
            } catch (IOException e)
            {
                 e.printStackTrace();
            }
            finally
            {
                try
                {
                     if(bufferedWriter != null)
                          bufferedWriter.close();
                } catch (IOException e)
                {
                     e.printStackTrace();
                }
            }

           8）常用操作

                 1.文本文件复制

              BufferedReader bufferedReader = null;
              BufferedWriter bufferedWriter = null;

              try
              {
                  bufferedReader = new BufferedReader(new FileReader("mm.txt"));
                  bufferedWriter = new BufferedWriter(new FileWriter("gg.txt"));

                  String line = null;
                  while((line=bufferedReader.readLine()) != null)
                  {
                      bufferedWriter.write(line);
                      bufferedWriter.newLine();//必须要加上
                   }
               } catch (IOException e)
               {
                  e.printStackTrace();
               }
               finally
               {
                   try
                   {
                         if(bufferedReader != null)
                                bufferedReader.close();
                   } catch (IOException e)
                   {
                         new RuntimeException(" reader close error");
                   }

                   try
                   {
                         if(bufferedWriter != null)
                               bufferedWriter.close();
                   } catch (IOException e)
                   {
                         new RuntimeException("writer close error");
                   }
                 }