javaIO--字节流

流---是指的一组有序的、有气垫和重点的字节集合，是对的护具传输的总称或者抽象。

流采用缓冲区技术，当写一个数据时，系统将数据发送到缓冲区而不是外部设备（如硬盘），当读一个数据时，系统实际是从缓冲区读取数据的。

流的存在：我们都知道输入流和输出流，二者的定义都是基于数据流向且是以内存为坐标的。标准输入过程中，数据从键盘等输入设备流向内存，这事输入流。标准输出过程中，数据从内存输出到显示器或者打印机等设备，这是输出流。

流分为字节流和字符流

下边主要讲标准输入输出、文件字节流、数据字节流和对象字节流四种字节流。

 public class IOtest {

     public static void main(String[] args) throws IOException {

 //        KeyboardInput();

 //        byte[] buffer = {0,1,2,3,4,5,6,7,8,9};
 //        ByteFile afile = new ByteFile("info.txt");
 //        afile.writeToFile(buffer);
 //        afile.readFromFile();
 //        afile.copyFile("io2.txt");

 //        IntFile afile = new IntFile("fileInt.txt");
 //        afile.writeToFile();
 //        afile.readFromFile();

         Student stus[] = {new Student("张三", "男"), new Student("李四", "女"), new Student("王五", "女博士")};
         objectFile afile = new objectFile("students.dat");
         afile.writeToFile(stus);
         System.out.println("stus: \n" + afile.readFromFile());
     }

     //标准输入输出
     public static void KeyboardInput() throws IOException{
         System.out.print("Input:");
         byte buffer[] = new byte[512];    //以字节数组作为缓冲区
         int count = System.in.read(buffer);
         System.out.print("Output:");
         for(int i=0; i<count; i++){
             System.out.print(" " + buffer[i]);
         }
         System.out.println("\ncount = " + count);
         for(int i=0; i<count; i++){
             System.out.print((char)buffer[i]);
         }
     }

     //文件字节流
     static class ByteFile{
         public String filename;
         public ByteFile(String filename){
             this.filename = filename;
         }
         //字节流写
         public void writeToFile(byte[] buffer) throws IOException{
             FileOutputStream fout = new FileOutputStream(this.filename);
             fout.write(buffer);
             fout.close();
         }
         //字节流读
         public void readFromFile() throws IOException{
             FileInputStream fin = new FileInputStream(this.filename);
             System.out.print(this.filename + ":");
             byte[] buffer = new byte[512];
             int count=0;
             while(count != -1){
                 count = fin.read(buffer);           //read返回值为字节数目，当为空时 返回-1
                 for(int i=0; i<count; i++){
                     System.out.print(buffer[i] + " ");
                 }
                 System.out.println(" count = " + count);
             }
             fin.close();
         }
         //文件字节流复制到filename2
         public void copyFile(String filename2) throws IOException{
             FileInputStream fin = new FileInputStream(this.filename);
             FileOutputStream fout = new FileOutputStream(filename2);
             byte[] buffer = new byte[512];
             int count = fin.read(buffer);                //读取输入流并返回流的大小
             while(count != -1){
                 fout.write(buffer, 0, count);
                 count = fin.read(buffer);
             }
             fin.close();
             fout.close();
             System.out.println("Copy file from " + this.filename + " to " + filename2);
         }
     }

     //数据字节流(举例 整形)
     //把fibonacci序列值写入指定文件
     static class IntFile{
         public String filename;
         public IntFile(String filename){
             this.filename = filename;
         }
         public void writeToFile() throws IOException{                   

             FileOutputStream fout = new FileOutputStream(this.filename);
             DataOutputStream dout = new DataOutputStream(fout);
             short i=0,j=1;
             do{
                 dout.writeInt(i);
                 dout.writeInt(j);
                 i = (short)(i+j);
                 j = (short)(i+j);
             }while(i>0);
             dout.close();
             fout.close();
         }
         public void readFromFile() throws IOException{
             FileInputStream fin = new FileInputStream(this.filename);
             DataInputStream din = new DataInputStream(fin);
             System.out.println(this.filename + ": ");
             while(true){
                 try {
                     int i = din.readInt();
                     System.out.print(i + " ");
                 } catch (Exception e) {
                     break;
                 }
             }
             din.close();
             fin.close();
         }
     }

     //对象字节流
     //使用对象字节流读写多个学生对象到某个指定文件
     static class objectFile{
         String filename;
         public objectFile(String filename){
             this.filename = filename;
         }

         public void writeToFile(Object[] objs) throws IOException{
             FileOutputStream fout = new FileOutputStream(this.filename);
             ObjectOutputStream obout = new ObjectOutputStream(fout);
             for(int i = 0; i<objs.length; i++){
                 obout.writeObject(objs[i]);
             }
             obout.close();
             fout.close();
         }

         public String readFromFile() throws IOException{
             FileInputStream fin = new FileInputStream(this.filename);
             ObjectInputStream obin = new ObjectInputStream(fin);
             System.out.println(this.filename + ": ");
             String str = "";
             while(true){
                 try {
                     str += obin.readObject().toString() + "\n";
                 } catch (Exception e) {
                     break;
                 }
             }
             obin.close();
             fin.close();
             return str;
         }
     }
     public static class Student implements Serializable{//内部类 学生对象

         private String name;
         private String sex;
         public Student(String name, String sex){
             this.name = name;
             this.sex = sex;
         }
         public String toString(){
             return "姓名： " + this.name + "    性别： " + this.sex;
         }
      }
 }