JAVA中IO流体系和使用（IO流）

阳光穿透心脏的1/2处 2022-05-27 09:25 252阅读 0赞

## 1.  IO流： ##

##     字节流： ##

抽象父类：

1.   InputStream

2.   OutputStream

文件流：

1.   FileInputStream

2.   FileOutputStream

字节缓冲流：

1.   BufferedInputStream

2.   BufferedOutputStream

ps:字节流可以操作任意类型的数据

**字符流：**

抽象基类：

1.   Reader

2.   Writer

转换流:

1.   InputStreamReader

2.   OutputStreamWriter

flush()

字符缓冲流：特点：可以按行读写数据

1.   BufferedReader

readLine() - String

2.   BufferedWriter

PrintWriter

i.      特殊的功能：自动行刷新

ii.      print  println

ps:字符流只能操作文本类型的数据

**对象流：**

ObjectInputStream

1.   readObject() -Object

ObjectOutputStream

1.   writeObject()

序列化：

1.   对象数据à字节数据   序列化

实现：

让对象所属的类型实现Serializable接口

2.   字节数据à对象     反序列化

注意的问题：

1.   反序列化时造成版本不兼容问题的原因以及解决办法：在对象所属的类中生成序列版本号

2.   如果一个对象是可序列化的，这个对象所属的类内部有其他的对象作为它的成员，那么作为成员的这个对象也一定是可序列化的

3.   如果一个对象内部的数据并非全部要持久化，此时可以用transient来修饰不持久化的数据

#             RandomAccessFile文件操作: #

Java提供了一个可以对文件随机访问的操作，访问包括读和写操作。该类名为RandomAccessFile。该类的读写是基于指针的操作。

RandomAccessFile也叫做随机访问流

RandomAccessFile在对文件进行随机访问操作时有两个模式，分别为只读模式(只读取文件数据)，和读写模式(对文件数据读写)。

1.字节流：

//创建输入流/输出流对象
    FileInputStream fis = new
            FileInputStream("fis.java");
    FileOutputStream fos = new
            FileOutputStream("copy1.txt");
    
    //按照单个字节复制
    int by = -1;
    while((by=fis.read())!=-1){
        //将by写入目标文件中
        fos.write(by);
    }
    
    //按照字节数组复制文件
    byte[] bys = new byte[1024];
    int  len = 0;
    while((len=fis.read(bys))>0){
        //将读取到的字节数组写入目标文件中
        fos.write(bys, 0, len);
    }
    //关闭流对象
    fis.close();
    fos.close();

2.字节缓冲流

//创建流对象
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("1.jpg"));
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2.jpg"));
    //完成复制
    byte[] bys = new byte[1024];
    int len = -1;
    while((len=bis.read(bys))!=-1){
        bos.write(bys, 0, len);
        bos.flush();
    }
    
        bis.close();
        bos.close();

3.字符流

//创建输入流对象
    InputStreamReader isr = new InputStreamReader(new FileInputStream("love.txt"),"UTF-8");
    //创建输出流对象
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"UTF-8");
    
    //读取
    //按照单个字符读取
    //    int ch = -1;
    //    while((ch=isr.read())!=-1){
    //       osw.write(chs, 0, len);
    //    }
    //按照字符数组读取
    char[]  chs = new char[1024];
    int len = -1;
    while((len=isr.read(chs))!=-1){
        //char[]-->String
        osw.write(chs, 0, len);
    }
    //释放资源
    isr.close();
    osw.close();

4.字符缓冲流

//创建输入，输出流对象
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("fis.java")));
    PrintWriter pw = new PrintWriter(new FileOutputStream("buffer.txt"),true);
    
    //复制
    String str = null;
    while((str=br.readLine())!=null){
        pw.println(str);
    }
    //流关闭
    br.close();
    pw.close();

5.对象流

/           //User类成员变量
    private String name;
    private String pass;
    //transient关键字：
    //当一个属性被transient修饰后,该属性在进行对象序列化时其值会被忽略.
    //忽略不必要的属性值可以达到对象序列化"瘦身"的效果.
    private transient String desc;

* 将User对象序列化到文件中
       * 要实现将User对象中的desc数据不写入文件
       */
    User user = new User("starry","123","描述");
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("transient.txt"));
    
    oos.writeObject(user);
    oos.close();
    
    //反序列化操作
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("transient.txt"));
    User per = (User)ois.readObject();
    
    System.out.println(per.getName()+per.getPass()+per.getDesc());
    
    ois.close();

6.RandomAccessFile随机访问流

RandomAccessFile ra = new RandomAccessFile("web/love.txt","rw");
        RandomAccessFile ra1 = new RandomAccessFile("web/love-copy.txt","rw");
        byte[] by = new byte[1024];
        int i= -1;
        while((i = ra.read(by)) != -1 ){
            ra1.write(by,0,i);
        }
        ra.close();
        ra1.close();

//创建RandomAccessFile对象
    RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
    
    //移动指针偏移量并读取偏移量之后的内容到临时文件中
    raf.seek(3);
    //创建临时文件
    File tmp = File.createTempFile("copy", ".tmp");
    //复制
    RandomAccessFile raftmp = new RandomAccessFile(tmp, "rw");
    byte[] bys = new byte[1024];
    int len = -1;
    while((len=raf.read(bys))!=-1){
        raftmp.write(bys, 0, len);
    }
    
    raf.seek(3);
    //向raf.txt文件中插入数据
    raf.write("hello".getBytes());
    
    //将临时文件中的内容复制到本文件的最后
    raftmp.seek(0);
    len = -1;
    while((len=raftmp.read(bys))!=-1){
        raf.write(bys, 0, len);
    }

//删除临时文件
    tmp.deleteOnExit();
    
    raf.close();
    raftmp.close();