IO输入输出流复习笔记 传智播客java

IO的分类

字节的输入输出

字节输出流

FileOutputStream 输出步骤
1 创建输出流对象
2 写数据
3 释放资源

 FileOutputStream fos = new FileOutputStream("fbb.txt");
        fos.write("测试".getBytes());//可以写字节
    
        // 字节数组 和指定数组的部分内容
        fos.close();//让流对象关闭可以接着使用
             fos.write("97".getBytes());//可以写字节

进行换行操作使用\n

    for(int i=0;i<10;i++){
            fos.write(("牛逼"+i).getBytes());
            fos.write("\n".getBytes());
        }

文件追加写入

      FileOutputStream fos = new FileOutputStream("fbb.txt",true);

通过他的构造方法可以知道写true表示文件已存在从尾部写入

字节输入

读取步骤
1 创建字节输入流对象
2 调用read（）方法读取数据显示到控制台
3 释放资源

      FileInputStream s1 = new FileInputStream("fbb.txt");
        System.out.println(s1.read());//一次读取一个字节

返回一个字节类型回来

 FileInputStream s1 = new FileInputStream("fbb.txt");
        int by =s1.read();
      while ((by=s1.read())!=-1){//因为他-1时候就是末尾
            System.out.print((char)by);
        }

用循环改进读写

复制文本文件

     FileInputStream s1 = new FileInputStream("fbb.txt");
        FileOutputStream s2= new FileOutputStream("fbb2.txt");
        int by =0;
        while ((by=s1.read())!=-1){//因为他-1时候就是末尾
            s2.write(by);//读取文本 写入进去另一个文本完成复制操作
        }

该方法不需要做转换中文不会出现问号

  FileInputStream s1 = new FileInputStream("D:\\sp_服务端.zip");//读取
        FileOutputStream s2= new FileOutputStream("D:\\测试.zip");//创建
        int by =0;
        while ((by=s1.read())!=-1){//因为他-1时候就是末尾
            s2.write(by);//读取文本 写入进去另一个文本完成复制操作
        }

案例复制压缩包

  FileInputStream s1 = new FileInputStream("D:\\sp_服务端.zip");//读取
        FileOutputStream s2= new FileOutputStream("D:\\测试.zip");//创建
        byte[]arr = new byte[1024];//每次读取10个字节
        int len = s1.read(arr);
        while (len!=-1){
            s2.write(arr);//写入数组
            len=s1.read(arr);

        }

使用数组优化速度，数组的长度一般都是1024或者是1024的整数倍

字节缓存流

BufferedOutputStream

   BufferedOutputStream buff = new BufferedOutputStream(new FileOutputStream("fbb"));
        //读取);
        buff.write("测试".getBytes());

字节缓冲区基础操作还是通过基本流对象实现

    BufferedInputStream buff=  new BufferedInputStream(new FileInputStream("fbb.txt"));
        byte[] ces = new byte[1024];
    int temp =0;
    while (temp!=-1){

        System.out.println(new String(ces,0,temp));
        temp = buff.read(ces);
    }

BufferedInputStream输入，同一个对象只能使用一个。

高效对比

字符流

字符流=字节流+编码表

转换流

输出

       OutputStreamWriter s1 = new OutputStreamWriter(new FileOutputStream("E:\\fbb.txt"),"UTF-8");

        s1.write("我嫩爹");
        s1.close();

用OutputStreamWriter一定要记得使用close否则内容会不完整

输入

    InputStreamReader s1 = new InputStreamReader(new FileInputStream("fbb2.txt"),"GBK");
    int ch = 0;
    while ((ch=s1.read())!=-1){
        System.out.println((char)ch);

    }

写入时候是什么编码那么读出时候就指定是什么编码

OutputStreamWriter的方法

写数据时候要记得刷新和关闭否则会在缓冲区导致没有写进去

InputStreamReader 的方法

字符缓冲流

提高效率，可以指定缓冲区大小

BufferedWriter输出

        BufferedWriter bw = new BufferedWriter(new FileWriter("我嫩爹.txt"));
        bw.write("哈哈哈哈");
        bw.flush();

BufferedReader 输入

        BufferedReader bw = new BufferedReader(new FileReader("我嫩爹.txt"));
        char[] cha = new char[1024];
        int ch= 0;
        while ((ch=bw.read(cha))!=-1){
            System.out.println(new String(cha,0,ch));
        }

字符缓冲流的特殊方法

readLine例子
注意：readLine是不带换行符的要带上newLine

IO小结图解

复制文本文件的五种案例方式

基本字符流一次读写一个字符

public static void metho(String src, String des) throws IOException {
        //基本字符流一次读写一个字符
        FileReader fr= new FileReader(src);//读入

        FileWriter s1 = new FileWriter(des);
        int ch=0;
        while((ch=fr.read())!=-1){
            s1.write(ch);
        }
        fr.close();;
        s1.close();
    }

基本字符流一次读写一个数组

    public static void metho1(String src, String des) throws IOException {
        FileReader fr= new FileReader(src);//读入

        FileWriter s1 = new FileWriter(des);
        char[]arr = new char[1024];
        int ch=0;
        while((ch=fr.read(arr))!=-1){
            s1.write(new String(arr ,0,ch));
        }
        fr.close();;
        s1.close();
    }

字符缓存流一次读写一个数组

public static void metho2(String src, String des) throws IOException {
        BufferedReader fr= new BufferedReader(new FileReader(src));//读入

        BufferedWriter s1 = new BufferedWriter(new FileWriter(des));
        char[]arr = new char[1024];
        int ch=0;
        while((ch=fr.read(arr))!=-1){
            s1.write(new String(arr ,0,ch));
        }
        fr.close();;
        s1.close();
    }

字符缓存流一次读写一个字符

    public static void metho4(String src, String des) throws IOException {
        //基本字符流一次读写一个字符
        BufferedReader fr= new BufferedReader(new FileReader(src));//读入

        BufferedWriter s1 = new BufferedWriter(new FileWriter(des));
        int ch=0;
        while((ch=fr.read())!=-1){
            s1.write(ch);
        }
        fr.close();;
        s1.close();
    }

字符缓存流一次读一行

 public static void metho5(String src, String des) throws IOException {
        //基本字符流一次读写一个字符
        BufferedReader fr= new BufferedReader(new FileReader(src));//读入

        BufferedWriter s1 = new BufferedWriter(new FileWriter(des));
        String line = null;
        while((line = fr.readLine())!=null){
            s1.write(line);
            s1.newLine();
            s1.flush();
        }
        fr.close();;
        s1.close();
    }

复制字节的四种基本案例

一次读写一个字节

    public static void metho(String src, String des) throws IOException {
        //一次读写一个字节
       FileInputStream s1 = new FileInputStream(src);
       FileOutputStream s2 = new FileOutputStream(des);
       int by = 0;
       while((by=s1.read())!=-1){
           s2.write(by);
       }
       s1.close();
       s2.close();
    }

一次读写一个字节数组

//一次读写一个字节数组
       FileInputStream s1 = new FileInputStream(src);
       FileOutputStream s2 = new FileOutputStream(des);
       byte[]arr= new byte[1024];

       int by = 0;
       while((by=s1.read(arr))!=-1){
           s2.write(arr,0,by);
       }
       s1.close();
       s2.close();

字节缓存流读取一个字节数组

    public static void metho(String src, String des) throws IOException {
    
       BufferedInputStream s1 = new BufferedInputStream(new FileInputStream(src));
       BufferedOutputStream s2 = new BufferedOutputStream(new FileOutputStream(des));
       byte[]arr= new byte[1024];

       int by = 0;
       while((by=s1.read(arr))!=-1){
           s2.write(arr,0,by);
       }
       s1.close();
       s2.close();
    }

字节缓存流读取一个字节

    public static void metho(String src, String des) throws IOException {
      
       BufferedInputStream s1 = new BufferedInputStream(new FileInputStream(src));
       BufferedOutputStream s2 = new BufferedOutputStream(new FileOutputStream(des));
 

       int by = 0;
       while((by=s1.read())!=-1){
           s2.write(by);
       }
       s1.close();
       s2.close();
    }

操作基本数据类型的流

使用例子

内存操作流

使用案例，内存操作流不需要写回收方法。

打印流

打印流是可以同时操作基本流和高级流

打印流作为子类循环的使用

打印流例子

效率相比之前更高效并且输出语句的本质就是打印流。

随机访问流

通过seek方法定位指针指针定位到哪就输出哪里。

合并流

    public static void main(String[] args) throws IOException {
        InputStream s1 = new FileInputStream("fbb.txt");
        InputStream s2 = new FileInputStream("fbb2.txt");
        SequenceInputStream sis = new SequenceInputStream(s1,s2);
        //该方法可以合并多个文本数据进行处理。
      
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("测试.txt"));
        byte[]by= new byte[1024];
        int ch =0;

        while ((ch=sis.read(by))!=-1){
            bos.write(by,0,ch);
        }
        bos.close();
        sis.close();
    }

添加多个文件的方法

序列化流

具体作用就是把一个对象写到文件，然后该对象就会变成流一样在文件中存储。将来还可以通过他把该对象还原

序列化步骤

读就叫序列化，写就叫反序列化

1 创建序列化对象
2 创建要序列化的对象
3 写序列化
4 释放资源

类要实现该接口才能启用序列化功能

该接口没有任何的方法，只是做一个标记的功能。

反序列号步骤

1 创建反序列化对象
2 还原对象
3 释放资源
4 输出对象


使用关键字让他不会被序列化

Properties的使用

Properties的特殊功能

Properties和IO流的结合使用

他可以直接把文本数据中的键值对存到集合中
他会自动处理切割到集合中

把集合中的数据存储到文件