【流】 测试文件流、字符流、对象流、缓存流

         在 Java 中，把所有的输入和输出都当做流来处理。 “ 流 ” 是一个抽象概念，它代表任何有能力产出数据的数据源对象或者是有能力接收数据的接收端对象。 “ 流 ” 屏蔽了实际的输入 / 输出设备中处理数据的细节。一个程序可以打开一个数据源上的流，然后按顺序读取这个流中的数据到程序中，这样的流称为输入流，一个程序也可以打开一个目的地的流，然后按顺序的把程序中的数据写入到这个目地中，这样的流称为输出流。

        Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。

流的分类：

           

     1.Java 的输入 / 输出流中，根据它们的数据类型，主要可分为两类：字符流 (Character Stream) 和字节流 (Btye Stream) 。

         字符流 (character Stream) 字符流的输入 / 输出数据是字符码。

         字符流有两个基本类： Reader 类和 Writer 类。 Reader 类用于处理字符输入流， Writer 类用于处理字符输出流。 它们都是抽象类，本身不能直接用来创建对象。提供了一些方法。  

         字节流 (Btye Stream) 字节流是按字节读 / 写二进制数据。 

         字节流有两个基本的类： InputStream 类和 OutputStream 类。 InputStream类用于处理字节输入流， OutputStream 类用于处理字节输出流。它们都是抽象类，本身不能直接用来创建对象。InputStream 类和 OutputStream 类为其它字节输入 / 输出流子类提供了一些基本方法和标准接口。

     2.按照流是否直接与特定的地方（如磁盘、内存等）相连，分为节点流与处理流。

         节点流：可以从或者向一个特定的地方（节点）读写数据。如文件流 FileReader 。  

         处理流：是对一个已经存在的流的连接和封装，通过所封装的流的功能调用实现数据读、写功能。处理流也称过滤流，如缓冲处理流BufferedReader 。

  字节流与字符流的差异：

      1、字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的，但是字符流在操作的 时候下后是会用到缓冲区的，是通过缓冲区来操作文件的。

     2、使用字节流好还是字符流好呢？

           字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。

字节和字符转换流

整个IO类中除了字节流和字符流外，还包括字节和字符转换流。

OutputStreramWriter将输出的字符流转化为字节流；InputStreamReader将输入的字节流转换为字符流。但是不管如何操作，最后都是以字节的形式保存在文件中的。

测试文件输出流：

@Test
    public void test1()throws Exception{

        FileOutputStream fout = new FileOutputStream("C:/Users/流/aa.txt");
        int a = 20;         //00000000  00000000   00000000  00010100
        byte[] b = {0,0,0,20};
        fout.write(b[0]);     //字符转换为字节    写入设备
        fout.write(b[1]);
        fout.write(b[2]);
        fout.write(b[3]);

        fout.close();
    }

  测试文件输入流：

 public void test2()throws Exception{
        FileInputStream ft = new FileInputStream("C:/Users/流/aa.txt");

        byte[] b = new byte[4];

        b[0] =(byte)ft.read();      // 字节转换为字符  读入程序
        b[1] =(byte)ft.read();
        b[2] =(byte)ft.read();
        b[3] =(byte)ft.read();

        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
        ft.close();
    }

 

 字符流：

@Test
    /**
     * 字符流
     */
    public void test5()throws Exception{
        OutputStream fout  = new FileOutputStream("C:/Users/流/aa.txt");
        String mesg  = "Hello World!你好世界！";
        byte[] ss = mesg.getBytes();  // 字符串   ---》  字节
        for(byte s:ss){
            fout.write(s);          // 写出每一个字节
        }
        fout.close();
    }

    @Test
    public void test6()throws Exception{
        InputStream ft  = new FileInputStream("C:/Users/流/aa.txt");
        byte[] b = new byte[ft.available()];// 新字节数组的长度为ft.available()
        int t;
        int i  =0;
        while((t = ft.read())!=-1){
            b[i] = (byte)t;
            i++;

        }
        String mesg  =new String(b);
        System.out.println(mesg);
        ft.close();
    }

 

 对象流 （高级流 装饰模式):

 @Test
    
    public void test7()throws Exception{

        OutputStream fout  = new FileOutputStream("C:/Users/流/aa.txt");

        ObjectOutputStream objout = new ObjectOutputStream(fout);//写字节
        //objout.write(2);  //对象流完成文件流的转换  转换为字节  完成数据流对字节流的转换

        Date d = new Date();
        objout.writeObject(d);
        objout.writeInt(24234);//对象流把24234整数转换成字节流
        objout.writeDouble(46.657);//对象流把浮点型整数转换为字节流
        objout.writeChar('S');
        objout.writeBoolean(true);
        objout.writeChars("ASFSGHDXFN");

        objout.flush();  //刷新
        //objout.close();
        fout.close();//释放流的资源
    }

    @Test
    public void test8() throws Exception {

        InputStream ft  = new FileInputStream("C:/Users/流/aa.txt");
        ObjectInputStream  q = new ObjectInputStream(ft);// 把字节转换为文件流

        Date d = (Date) q.readObject();
        System.out.println(d);
        int tt =  q.readInt(); // 读四个字节
        System.out.println(tt);
        double t1 = q.readDouble();
        System.out.println(t1);
        char t2 = q.readChar();
        System.out.println(t2);
        boolean t3 = q.readBoolean();
        System.out.println(t3);
        q.close();

    }
    @Test
    public void test9() throws Exception {
        OutputStream fout  = new FileOutputStream("C:/Users/流/aa.txt");
        ObjectOutputStream objout = new ObjectOutputStream(fout);//转换字节
        //高级流和低级流之间的合作
        Date d = new Date();
        objout.writeObject(d);
        Student s = new Student(435,"SSa");
        objout.writeObject(s);

        objout.flush();
        fout.close();//释放流的资源
    }
    @Test
    public void test10() throws Exception {
        InputStream ft  = new FileInputStream("C:/Users/流/aa.txt");
        ObjectInputStream  q = new ObjectInputStream(ft);// 把字节转换为文件流

        Date d = (Date) q.readObject();
        System.out.println(d);
        Student s = (Student) q.readObject();
        System.out.println(s);
        System.out.println(s.getId()+":" + s.getName());
        q.close();
    }

 

缓存流：

@Test
    //缓存  写入
    public void test13() throws Exception{
        ObjectOutputStream ob = new ObjectOutputStream(
                                    new BufferedOutputStream(
                                            new FileOutputStream("C:\\Users\\流/c.txt")
                                    )
                                 );
         Date d = new Date();
         ob.writeObject(d);

         Student s = new Student(243545,"dgsd");
         ob.writeObject(s);
         ob.flush();
         ob.close();
    }

    @Test
    //缓存  读入
    public void test14() throws Exception{
        ObjectInputStream obi = new ObjectInputStream(
                                    new BufferedInputStream(
                                            new FileInputStream("C:\\Users\\流/c.txt")
                                    )
                                   );
         Date d = (Date)obi.readObject();

         System.out.println(d);
         Student s = (Student) obi.readObject();
         System.out.println(s);
         obi.close();


    }