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;
        }
     }
}