JAVA中的I/O流

1. io流原理图

2. io流的分类             

3. 节点流和处理流

4. 对象流

   ---

   1.io流原理图

   

   ---

   2.io流分类

二者的速度是相对的，要根据目标文件的性质来选择合适的流  

字符流代码演示（适合处理二进制文件）

FileReader（读）

package COM.IO_;

import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * written by 刘瑞臻
 * time:2022/12/2 21:33
 */
public class file_reader {
   public static void main(String[] args) {

   }
   @Test
   public void test()
   {
      String  srcFilepath = "D:\\IO_test\\abc.txt";
      FileReader fileReader = null ;
      int len = 0 ;
      //一次读八个
      char[] data = new char[8];
      try {
         fileReader = new FileReader(srcFilepath);
         while ((len = fileReader.read(data))!=-1)
         {
            System.out.print( data);
         }
         System.out.println("读入成功");
      } catch (IOException e) {
         e.printStackTrace();
      }
      finally {
         try {
            fileReader.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
   }
}

Filewriter（写）

package COM.IO_;

import java.io.FileWriter;
import java.io.IOException;

/**
 * written by 刘瑞臻
 * time:2022/12/2 21:48
 */
public class file_writer {
   public static void main(String[] args) {
      String txt = "我亦无他，唯手熟而";
      String decPath = "D:\\IO_test\\hi.txt";
      char[] buf = {'a','b','c','d'};
      String a = "adlkhkn lbfe";
      FileWriter fileWriter = null;
      try {
          fileWriter = new FileWriter(decPath,true);
         fileWriter.write(txt);
         //写入单个字符
         fileWriter.write('H');
         //写入指定数组
         fileWriter.write(buf);
         //写入指定长度数组
         fileWriter.write(buf,0,2);
         fileWriter.write(a);

         System.out.println("写入成功");
      } catch (IOException e) {
         e.printStackTrace();
      }
      finally {
         try {
            //一定要关闭   不然就会写入不成功
            fileWriter.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
   }
}

字节流代码演示 （与字符流基本一致 在这里直接演示的的是用字节流进行图片copy）

package COM.IO_;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * written by 刘瑞臻
 * time:2022/12/1 11:31
 */
public class io_copy {
    public static void main(String[] args) {
//"C:\Users\lrzlx\Desktop\java.png"
    }

    @Test
    public void test01() {
        String a = "D:\\CNTV\\test.jpg";
        String c = "D:\\IO_test\\hello.jpg";

        int readlen = 0;
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream(a);
            fileOutputStream = new FileOutputStream(c);
            //定义一个字节数组 加快读取速度
            byte[] buf = new byte[1024];
            while ((readlen = fileInputStream.read(buf)) != -1) {
                //边读边写
                fileOutputStream.write(buf, 0, readlen);//
            }
            System.out.println("拷贝成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            {
                try {
                    if (fileInputStream != null)
                        fileInputStream.close();
                    fileOutputStream.close();
               } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }


    }

}

---

3.节点流与处理流

1. 节点流   可以在一个特定的而数据源读写数据
2. 处理流    也叫包装流，实在已存在的流的基础上，为程序提供更为强大的读写功能

所谓处理流就是对节点流进行包装，使用修饰器模式，不会直接与数据源相连 

BufferedReader/writer就是典型的处理流bufferreader就是处理流，所谓处理流就是用了修饰器模式，有了reader就可以使用其中的各种方法

（代码演示）

BufferedReader

package COM.IO_;

import java.io.*;

/**
 * written by 刘瑞臻
 * time:2022/12/3 11:48
 */
public class file_bufferedReader  {
   public static void main(String[] args) {
      String filepath = "D:\\IO_test\\abc.txt";
      BufferedReader bufferedReader = null;
      String line;//按行读取
      try {
          bufferedReader = new BufferedReader(new FileReader(filepath));
         while ((line = bufferedReader.readLine())!=null)
            System.out.println(line);
      } catch (IOException e) {
         e.printStackTrace();
      }
      finally {
         try {
            bufferedReader.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }

   }
}

BufferedWriter

package COM.IO_;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;

/**
 * written by 刘瑞臻
 * time:2022/12/3 17:12
 */
public class file_bufferedWriter {
    public static void main(String[] args) {
        String filePath = "D:\\IO_test\\abc.txt";
        String txt = "备战了";
        BufferedWriter bufferedWriter = null;
        try {
         bufferedWriter  = new BufferedWriter(new FileWriter(filePath,true));
            bufferedWriter.write(txt);
            //换行符
            bufferedWriter.newLine();
            bufferedWriter.write("决战2023");
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            bufferedWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 利用BufferedReader/writer进行拷贝

package COM.IO_;

import java.io.*;

/**
 * written by 刘瑞臻
 * time:2022/12/3 17:21
 */
@SuppressWarnings({"all"})
public class file_bufferedcopy {
    public static void main(String[] args) {


    String filePath = "D:\\IO_test\\hi.docx";
    String descPath = "D:\\Hello.docx";
    BufferedReader bufferedReader = null;
    BufferedWriter bufferedWriter = null;
    String buff = null;
        try {
          bufferedReader = new BufferedReader(new FileReader(filePath));
          bufferedWriter = new BufferedWriter(new FileWriter(descPath,true));
            while ((buff = bufferedReader.readLine())!=null)
            {
                bufferedWriter.write(buff);
            }
            System.out.println("拷贝成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if (buff!=null)
            bufferedReader.close();
            if (buff!=null)
            bufferedWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }}

---

4.对象流

有时候保存数据的时候并不只是保存这个数据的值，还需要保存着个数据的类型 这时候就需要我们的对象流

序列化与反序列化

• 序列化就是在保存数据时，保存数据的值和数据的类型

• 反序列化就是在恢复数据时，恢复数据的值和类型

要想让文件知道这是对象流，还必须”打上标记“

打上标记必须实现以下接口：  Serializable  这仅仅是个标识，没有具体方法实现

                                  Externalizable 该接口有具体方法 需要实现方法

序列化代码

package COM.IO_;

import java.io.*;

/**
 * written by 刘瑞臻
 * time:2022/12/3 19:19
 */
public class file_object {
    public static void main(String[] args) throws IOException {
        String filePath = "D:\\IO_test\\data.txt";
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化对象
        os.writeInt(100);//Intege  实现了
        os.writeBoolean(true);
        os.writeObject(new Dog("cc", 10));
        os.close();
    }
}

class Dog implements Serializable {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

反序列化代码（一定要与写的类型的顺序对应一致）

package COM.IO_;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.zip.InflaterInputStream;

/**
 * written by 刘瑞臻
 * time:2022/12/3 20:13
 */
public class file_getobject {
    public static void main(String[] args) throws IOException {
        //指定反序列化文件
        String filePath = "D:\\IO_test\\data.txt";
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readBoolean());
        try {
            System.out.println(objectInputStream.readObject());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        objectInputStream.close();
    }
}