理一理*******IO操作（三）

   除了将流分为输入流和输出流之外，按照是否与数据源直接连接，还可以分为实体流和装饰流，前面提到的FileOutputStream/FileInputStream和FileReader/FileWriter都是实体流。装饰流是以其他的实体流或装饰流为基础建立的流类，该类流实现了将实体流中的数据进行转换，增强流对象的读写功能，比较常用的有DataInputStream/DataOutputStream。

创建装饰流的方式被称为“流的嵌套”。

  例子：DataInputStream/DataOutputStream的使用，所有文件在同一个包中。

一，创建一个自己的数据类型供后面的读取所用：MyData.java

package file;

/**

 * 需要存到文件中的数据

 * 有四种类型的数据

 * @author 幸运皮

 *

 * */

public class MyData {

    boolean b;

    int n;

    String s;

    short sh[];

   

    public MyData(){}

   

    public MyData(boolean b, int n, String s, short sh[]){

       this.b = b;

       this.n = n;

       this.s = s;

       this.sh = sh;

      

    }

}

二，写数据：WriteFileUseDataStream.java

package file;

import java.io.*;

public class WriteFileUseDataStream {

 

    /**

     * 用DataOutputStream将MyData的内容写入文件中

     * @author 幸运皮

     */

    public static void main(String[] args) {

       short sh[] = {1,2,3,4};

       MyData data = new MyData(true,100,"java",sh);

       writeFile(data);

 

    }

   

    public static void writeFile(MyData data){

       FileOutputStream fos = null;

       DataOutputStream dos = null;

       try{

           fos = new FileOutputStream("f://test.my");

           dos = new DataOutputStream(fos);

           dos.writeBoolean(data.b);

           dos.writeInt(data.n);

           dos.writeUTF(data.s);

          

           int len = data.sh.length;

           dos.writeInt(len);//记录下长度

          

           for(int i=0;i < len; i++){

              dos.writeShort(data.sh[i]);

           }

          

       }catch(Exception e){

           e.printStackTrace();

       }finally{

           try{

              dos.close();

              fos.close();

           }catch(Exception e2){

              e2.printStackTrace();

           }

       }

      

    }

 

}

/*首先建立一个实体流，然后以该实体流为基础，使用流的嵌套，建立装饰流对象*/

三，读取刚刚写入的数据：ReadFileUseDataStream.java

package file;

import java.io.*;

/**

 * 使用DataInputStream读取test.MY的文件内容

 * @author 幸运皮

 *

 */

public class ReadFileUseDataStream {

 

         public static void main(String[] args) {

                  MyData data = readFile();

                  System.out.print(data.b);

                  System.out.print(data.n);

                  System.out.print(data.s);

                  for(int i=0;i < data.sh.length;i++){

                          System.out.print(data.sh[i]);

                  }

                 

         }

                 

                  public static MyData readFile(){

                          MyData data = new MyData();

                          FileInputStream fis = null;

                          DataInputStream dis = null;

                          try{

                                   fis = new FileInputStream("f://test.MY");

                                   dis = new DataInputStream(fis);

                                   data.b = dis.readBoolean();

                                   data.n = dis.readInt();

                                   data.s = dis.readUTF();

                                   int len = dis.readInt();

                                   data.sh = new short[len];

                                   for(int i = 0;i < len;i++){

                                            data.sh[i] = dis.readShort();

                                   }

                          }catch(Exception e){

                                            e.printStackTrace();

                                   }finally{

                                            try{

                                                     dis.close();

                                                     fis.close();

                                            }catch (Exception e1){

                                                     e1.printStackTrace();

                                            }

                                   }

                          return data;    

                          }

                 

                 

                 

         }

 

 （暂时结束）