12.3  字节流与字符流基本操作
    在java.io包中流的操作主要有字节流、字符流两大类，两类都有输入和输出操作。在字节流中输出数据主要使用OutputStream类完成，输入使用的是InputStream类。在字符流中输出主要是使用Writer类完成，输入主要是使用Reader类完成。
    在Java中IO操作也是有相应步骤的，以文件的操作为例，主要的操作流程如下：
    （1）使用File类打开一个文件。
    （2）通过字节流或字符流的子类指定输出的位置。
    （3）进行读/写操作。
    （4）关闭输入/输出。
    12.3.1  字节流（1）
    字节流主要操作byte类型数据，以byte数组为准，主要操作类是OutputStream类和InputStream类。
    1．字节输出流：OutputStream
    OutputStream是整个IO包中字节输出流的最大父类，此类的定义如下：
             public abstract class OutputStream  extends Object  implements Closeable, Flushable          从以上定义中可以发现，OutputStream类是一个抽象类，如果要使用此类，则首先必须 通过子类实例化对象。如果现在要操作的是一个文件，则可以使用FileOutputStream类，通过向上转型后，可以为OutputStream实例 化，在OutputStream类中的主要操作方法如表12-3所示。
    表12-3  OutputStream类的常用方法
     
                                        序号
                            方    法
                            类型
                            描    述
                                                                            1                
                                                public void close() throws                 
                                    IOException                
                            普通
                            关闭输出流
                                                                            2                
                                                public void flush() throws                
                                     IOException                
                            普通
                            刷新缓冲区
                                                                            3                
                                                public void write(byte[] b)                 
                                    throws IOException                
                            普通
                            将一个byte数组写入数据流
                                                                            4                
                                                public void write(byte[]                 
                                    b,int off,int len) throws 
IOException                
                            普通
                            将一个指定范围的
                                    byte数组写入数据流
                                                                            5                
                                                public abstract void write(int b)                 
                                    throws IOException                
                            普通
                                                                                    将一个字节数据写入数据流                
                             
    此时使用FileOutputStream子类，此类的构造方法如下：
    public FileOutputStream(File file) throws FileNotFoundException
    操作时必须接收File类的实例，指明要输出的文件路径。
    U提示：关于Closeable和Flushable接口的说明。
    在OutputStream类的定义中可以发现此类实现了Closeable和Flushable两个接口，那么这两个接口的定义如下。
     Closeable接口：
             public interface Closeable{                        void close() throws IOException                    }  
                  Flushable接口：
             public interface Flushable{                        void flush() throws IOException                    }          这两个接口的作用从其定义方法中可以发现，Closeable表示可关闭，Flushable表示可刷新，而且在OutputStream类中已经有了这两个方法的实现，所以操作时用户一般不会关心这两个接口，而直接使用OutputStream类即可。
    范例：向文件中写入字符串
             package org.lxh.demo12.byteiodemo;                    import java.io.File;                    import java.io.FileOutputStream;                    import java.io.OutputStream;                    public class OutputStreamDemo01 {                        public static void main(String[] args) throws Exception {   // 异常抛出，  不处理                            // 第1步：使用File类找到一个文件                            File f = new File("d:" + File.separator + "test.txt"); // 声明File  对象                            // 第2步：通过子类实例化父类对象                            OutputStream out = null;       // 准备好一个输出的对象                            out = new FileOutputStream(f); // 通过对象多态性，进行实例化                            // 第3步：进行写操作                            String str = "Hello World!!!"; // 准备一个字符串                            byte b[] = str.getBytes();   // 只能输出byte数组，所以将字符串变为  byte数组                            out.write(b);               // 将内容输出，保存文件                            // 第4步：关闭输出流                            out.close();               // 关闭输出流                        }                    }          可以发现内容已经成功地写入到文件中，以上程序在实例化、写、关闭时都有异常   发生，为了方便起见，直接在主方法上使用thorws关键字抛出异常，可以减少try…catch语句。
    U提示：文件不存在则会自动创建。
    在以上操作的test.txt文件，在操作之前本身是不存在的，但是操作之后程序会为用户自动创建新的文件，并将内容写入到文件之中。
    以上操作是直接将一个字符串变为byte数组，然后将byte数组直接写入到文件中，当然也可以通过循环把每一个字节一个个地写入到文件之中 。
    范例：使用write(int t)的方式写入文件内容
             package org.lxh.demo12.byteiodemo;                    import java.io.File;                    import java.io.FileOutputStream;                    import java.io.OutputStream;                    public class OutputStreamDemo02 {                        public static void main(String[] args) throws Exception { // 异常抛出，  不处理                            // 第1步：使用File类找到一个文件                            File f = new File("d:" + File.separator + "test.txt");// 声明File  对象                            // 第2步：通过子类实例化父类对象                            OutputStream out = null;      // 准备好一个输出的对象                            out = new FileOutputStream(f);   // 通过对象多态性，进行实例化                            // 第3步：进行写操作                            String str = "Hello World!!!";  // 准备一个字符串                            byte b[] = str.getBytes();      // 只能输出byte数组，所以将字符串变  为byte数组                            for (int i = 0; i < b.length; i++) {                                out.write(b);           // 将内容输出                            }                            // 第4步：关闭输出流                            out.close();              // 关闭输出流                        }                    }          上面程序是将byte数组中的内容一个个地写入到文件之中，实现的功能与上一个程序是一致的。以上两种做法并没有什么不同，两者可以任意使用。
    2．追加新内容
    之前的所有操作中，如果重新执行程序，则肯定会覆盖文件中的已有内容，那么此时可以通过FileOutputStream向文件中追加内容，FileOutputStream的另外一个构造方法如下：
             public FileOutputStream(File file,boolean append) throws FileNotFoundException          在构造方法中，如果将append的值设置为true，则表示在文件的末尾追加内容。
    范例：修改之前的程序，追加文件内容
             package org.lxh.demo12.byteiodemo;                    import java.io.File;                    import java.io.FileOutputStream;                    import java.io.OutputStream;                    public class OutputStreamDemo03 {                        public static void main(String[] args) throws Exception { // 异常抛出，  不处理                            // 第1步：使用File类找到一个文件                            File f = new File("d:" + File.separator+ "test.txt");// 声明File  对象                            // 第2步：通过子类实例化父类对象                            OutputStream out = null;            // 准备好一个输出的对象                            out = new FileOutputStream(f,true);// 此处表示在文件末尾追加内容                            // 第3步：进行写操作                            String str = "Hello World!!!";    // 准备一个字符串                            byte b[] = str.getBytes();         // 只能输出byte数组，所以将字符串变  为byte数组                            for (int i = 0; i < b.length; i++) {                                out.write(b);           // 将内容输出                            }                            // 第4步：关闭输出流                            out.close();                  
             // 关闭输出流                        }                    }          程序运行结果：
                        [url=]http://img.bimg.126.net/photo/Vx0uFRjS0OWQlpEPrtVYxA==/5747437549455188781.jpg [/url]                可以发现，每次执行后，内容会自动追加到文件的末尾。
    提问：如何增加换行？
    上面程序确实在文件之后追加内容，可是内容是紧跟在原有内容之后的，如何在文件中增加换行，使文件内容显示更加清晰呢？
    回答：使用\r\n增加换行。
    如果要换行，则直接在字符串要换行处加入一个"\r\n"。
             // 第3步：进行写操作                    String str = "\r\n Hello World!!!"; // 准备一个字符串          程序运行结果：
                        [url=]http://img.bimg.126.net/photo/Lfi6lxIU2OQA5xU01EzxZQ==/5747437549455188783.jpg [/url]                  从结果中发现，新的内容是在换行之后追加的。
    12.3.1  字节流（3） 
     3．字节输入流InputStream（输入到程序中）
    既然程序可以向文件中写入内容，则可以通过InputStream从文件中把内容读取进来。InputStream类的定义如下：
             public abstract class InputStream  extends Object  implements Closeable          与OutputStream类一样，InputStream本身也是一个抽象类，必须依靠其子类，如果现在从文件中读取，子类肯定是FileInputStream。InputStream类中的主要方法如表12-4所示。
    表12-4  InputStream类的常用方法
                                                            序号                
                                                方    法                
                                                类型                
                                                描    述                
                                                                            1                
                                                public int available() throws                 
                                    IOException                
                                                普通                
                                                可以取得输入文件的大小                
                                                                            2                
                                                public void close() throws                
                                     IOException                
                                                普通                
                                                关闭输入流                
                                                                            3                
                                                public abstract int read()                 
                                    throws IOException                
                                                普通                
                                                读取内容，                
                                    以数字的方式读取                
                                                                            4                
                                                public int read(byte[] b) throws                
                                    IOException                
                                                普通                
                    &