字节流 缓存流 对象流

IO就是通过IO流文件的内容进行操作

        IO中的4个基类：

                InputStream 字节输入流

                OutputStream 字节输出流

                Reader：字符输入流

                Writer 字符输出流

完成文件内容的复制：

        要求D:/AAA/c.text 复制到 C：/AAA/d.text

Junit 单元测试 @Test 相当于每个方法都可以独立的运行相当于等价main函数

单元测试 修饰符public 返回类型void 而且方法没有形参

public class T {

    @Test
    public void Test01() throws Exception{
        //将 读取中的内容出入另一个文件中
        //1.创建一个字符输入流  作用：读取文件中的内容
        FileReader f=new FileReader("D:/AAA/aaa.text");
        //2.创建一个字符输出流 作用： 对文件进行操作
        FileWriter w=new FileWriter("C:/AAA/a.text");
        //进行读取
        int cont=0;
        //将每读取的内容存入数组c1中
        char[] c1=new char[3];
        //如果cont返回的不是-1 进入循环
        while ((cont=f.read(c1))!=-1){
            //将 f.read读取的内容写到 w.write当中
            w.write(c1,0,cont);
            //刷新
            w.flush();
        }
            f.close();
            w.close();
    }
}

可不可以复制一个电影 图片 压缩文件

        字符流没有办法对电影 图片 压缩文件进行复制 它只能对文本进行操作。因为视频 图片这些都属于二进制

字节输出流-OutputStream

        它是可以对任意文件进行操作，对文件输出操作，以字节为单位，它是所有字节输出流的父类 子类是FileOutputStream

如果没有创建文件，会帮助你创建文件，但是不能创建文件夹

 

        怎样解决：将字符串转为字节

public class Test05 {
    @Test//测试字节输出流
    public void Test05() throws Exception{
        OutputStream out=new FileOutputStream("D:/AAA/aaa.test");
        //为什么报错
       String str="abc";
       //将字符串转换为字节 getBytes()获得字节
       // out.write(bytes,0,2);这样也可以
        byte[] bytes=str.getBytes();
        out.write(bytes);
        //刷新 关闭
        out.flush();
        out.close();
    }
}

字节流输入流--InputStream

        它可以对任意文件进行操作，以字节为单位，它是所有字节输入流的父类 子类：FileInputStream

        1.一次一次的读取

@Test
//
//输入流 作用:读取文件中的内容
public void Test06() throws Exception{
    InputStream in=new FileInputStream("D:/AAA/bbb.text");
    byte[] bytes=new byte[3];
    //一次读取3个字节，并且把读取的内容放入字节数组中，返回读取到的个数
    int read = in.read(bytes);
}

        2.循环的读取

@Test
public void Test07() throws Exception{
    //循环读取
    InputStream in=new FileInputStream("D:/AAA/bbb.text");
    //一次读取3个字节，并且把读取的内容放入字节数组中，返回读取到的个数3
    byte[] bytes=new byte[3];
    int count=0;
    while ((count=in.read(bytes))!=-1){
        //System.out.println(bytes);
        //把byte字节转为字符串
        String str=new String(bytes,0,count);
        System.out.println(str);
    }
    in.close();


}

        3.复制文字 图片 视频压缩文件

@Test
public void Test08() throws Exception{
    //创建一个字节输入流
    InputStream in=new FileInputStream("D:/AAA/bbb.text");
    //创建一个字节输出流
    OutputStream out=new FileOutputStream("C:/AAA/b.text");
    //读取内容
    byte[] bytes=new byte[3];
    int count=0;
    while ((count=in.read(bytes))!=-1){
        out.write(bytes,0,count);
    }
    in.close();
    out.close();
}

缓存流/处理流

        1.缓存流的作用：

        是在基础（InputStream OutputStream Reader Writer）之上的，添加了一个缓存池功能

        2.BufferInputStream BufferOutputStream BufferReader BufferWriter 提高IO的效率，降低IO的次数

public class Test1 {
    @Test
    //测试缓存流它是再基本流的基础上进行扩展的
    public void Test011() throws Exception{
        OutputStream out=new FileOutputStream("D:/AAA/c.text");
        //因为 BufferedOutputStream 是要作用于基础流之上的
        //BufferedOutputStream里面可以缓存8192个字节 如果找过了8192个字节就会写入到 c.text
        BufferedOutputStream buf=new BufferedOutputStream(out);
        String str="北京欢迎你，希望你可以玩的开心";
        byte[] bytes = str.getBytes();
        //文件中c.text没有我们刚刚写入的，是因为什么？
        //因为你写入的内容暂时放在缓存池中，没有直接放到文件当中，所以文件当中并没有我们刚写入的内容
        buf.write(bytes);
        //怎样让我们的内容显示在 文件中
        buf.flush();
        //刷新缓存池  把缓存池中的内容输入到文件上
        buf.close();
        //关闭缓存池 先刷新缓存池 在关闭流资源
    }

对象流-对java对象进行IO操作

        1.为什么需要对象流

                我们现在操作IO流的时候都是将字符串读写操作。

                将java对象进行读写操作意义在于持久化信息 例如：游戏存档

                因为运行的时候 所有的数据都是在运行内存中的 持久化：将运行内存的数据保存到硬盘内存 存档（写） 读档（读）

             2.序列化：

                        把内存中的java对象储存到磁盘（网盘）的过程

                        要求：java对象所属的类必须实现序列化接口.implements serializable

                3.反序列化：

                        把磁盘中的内容读取到java对象内存中的过程

public class RoleTest {
    @Test
    //这个叫做存档--存档的专业叫做：序列化
    public void Test() throws Exception{
        OutputStream out=new FileOutputStream("D:/AAA/s.text");
        //创建一个对象输出流
        ObjectOutputStream obj=new ObjectOutputStream(out);
        //使用对象输出流的调用输出方法 输出的类对象 该类对象必须实现Serializable 序列换接口
        Role r=new Role("王大力","4级","玩游戏",1);
        obj.writeObject(r);
        obj.close();
    }
    @Test
    //读档--反序列化
    public void Test02()throws Exception {
        InputStream in=new FileInputStream("D:/AAA/s.text");
        ObjectInputStream out=new ObjectInputStream(in);
        Object o = out.readObject();
        System.out.println(o);
        out.close();
    }
}

总结：

1.通过字符流完成文件的复制--它只能复制文本文件

2.字节流--字节输入流和字节输出流

3.字节流 我们也可以完成文件的复制功能---它是复制任意类型文件

4.缓存流-- 它基本流的基础上添加了一个缓存池

5.对象流 ：ObjectInputStream ObjectOutputStream

序列化 反序列化