java IO流【常用流对象三】

﹏ヽ暗。殇╰゛Y 2024-04-01 11:30 76阅读 0赞

> 本文章学自尚学堂，如有侵权，请及时联系！谢谢  
> 
> 
> #### 文章目录 ####
> 
>  *  8 对象流
>  *   *  8.1 java对象的序列化和反序列化
>      *   *  8.1.1 序列化和反序列化
>          *  8.1.2 对象序列化的作用
>          *  8.1.3 序列化涉及的类和接口
>      *  8.2 操作基本数据类型
>      *   *  8.2.1 写出基本数据类型数据
>          *  8.2.2 读取基本数据类型数据
>      *  8.3 操作对象
>      *   *  8.3.1 将对象序列化到文件
>          *   *  8.3.1.1 创建对象
>              *   *  8.3.1.2 序列化对象
>          *  8.3.2 将对象反序列化到内存中
>  *  9 随机访问流
>  *   *  9.1 三个核心方法
>  *  10 FIle类在IO中的作用

## 8 对象流 ##

*  ***对象的本质是用来组织和存储数据的，对象本身也是数据。那么，能不能将对象存储到硬盘上的文件中呢？能不能将对象通过网络传输到另一个电脑呢？我们可以通过序列化和反序列化***来实现这些需求。

### 8.1 java对象的序列化和反序列化 ###

#### 8.1.1 序列化和反序列化 ####

*  当两个进程远程通信时，彼此可以发送各种类型的数据。\*\*\*无论是何种类型的数据，都会以二进制序列的形式在网络上传送。\*\*\*比如，我们可以通过http协议发送字符串信息；我们也可以在网络上直接发送Java对象。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象才能正常读取。
 *  ***序列化：把Java对象转化为字节序列的过程***
 *  ***反序列化：把自己恢复为java对象的过程***

#### 8.1.2 对象序列化的作用 ####

*  ***持久化：把对象的字节序列永久地保存到磁盘上，通常放在一个文件中。***
 *  ***网络通信：在网络上传输对象的字节序列。***

#### 8.1.3 序列化涉及的类和接口 ####

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ObjectOutputStream代表对象输出流</td> 
   <td>它的writeObject(Object obj）方法可对参数指定的obi对象进行序列化，把得到的学节序列写到一个自标输出流中。</td> 
  </tr> 
  <tr> 
   <td>ObjectinputStream代表对象输入流</td> 
   <td>它的readobject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。</td> 
  </tr> 
 </tbody> 
</table>

> ***只有实现了Serializable接口的类的对象才能被序列化。Serializable接口是一个空接口只起到标记作用。***  
> ***如果一个接口没有任何抽象方法，那么这个接口就是一个标识接口。***

### 8.2 操作基本数据类型 ###

*  前边的数据流只能实现对***基本数据类型和字符串类型***的读写，并不能对Java对象进行读写操作（字符串除外），但是***对象流中除了能实现对基本数据类型进行读写操作以外，还可以对Java对象进行读写操作。***

#### 8.2.1 写出基本数据类型数据 ####

package IO流.对象流;
    
    import java.io.BufferedOutputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectOutputStream;
    
    /**
     * @author 缘友一世
     * date 2022/10/27-16:49
     */
    public class ObjectOutputStreamBasicTypeDemo {
        
        public static void main(String[] args) {
        
            ObjectOutputStream oos=null;
            try {
        
                oos=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("basic grammar/src/IO流/对象流/text1.txt")));
                oos.writeInt(1024);
                oos.writeDouble(Math.random());
                oos.writeChar('x');
                oos.writeUTF("中国加油！");
                oos.flush();
            }catch (Exception e) {
        
                e.printStackTrace();
            }finally {
        
                try{
        
                    if(oos!=null) {
        
                        oos.close();
                    }
                }catch (Exception e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

#### 8.2.2 读取基本数据类型数据 ####

package IO流.对象流;
    
    import java.io.BufferedInputStream;
    import java.io.FileInputStream;
    import java.io.ObjectInputStream;
    
    /**
     * @author 缘友一世
     * date 2022/10/27-17:02
     */
    public class ObjectInputStreamBasicTypeDemo {
        
        public static void main(String[] args) {
        
            ObjectInputStream ois=null;
            try {
        
               ois=new ObjectInputStream(new BufferedInputStream(new FileInputStream("basic grammar/src/IO流/对象流/text1.txt")));
               //必须要按照写入的顺序读取数据
                /*
                *   oos.writeInt(1024);
                    oos.writeDouble(Math.random());
                    oos.writeChar('x');
                    oos.writeUTF("中国加油！");
                * */
                System.out.println("int："+ois.readInt());
                System.out.println("double："+ois.readDouble());
                System.out.println("char："+ois.readChar());
                System.out.println("utf："+ois.readUTF());
                
            }catch (Exception e) {
        
                e.printStackTrace();
            }finally {
        
                try{
        
                    if(ois!=null) {
        
                        ois.close();
                    }
                }catch (Exception e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

![在这里插入图片描述][a5ea1b46655f43b2add79771cfec019b.png]

### 8.3 操作对象 ###

#### 8.3.1 将对象序列化到文件 ####

*  ObjectOutputstream可以将一个内存中的Java对象通过序列化的方式写入到磁盘的文件中。被序列化的对象必须要实现  
    Serializable序列化接口，否则会抛出异常。

##### 8.3.1.1 创建对象 #####

package IO流.对象流;
    
    import java.io.Serializable;
    
    /**
     * @author 缘友一世
     * date 2022/10/27-17:19
     */
    public class User implements Serializable {
        
        private int userId;
        private String userName;
        private String userAge;
    
        public User() {
        
        }
    
        public User(int userId, String userName, String userAge) {
        
            this.userId = userId;
            this.userName = userName;
            this.userAge = userAge;
        }
    
        public int getUserId() {
        
            return userId;
        }
    
        public void setUserId(int userId) {
        
            this.userId = userId;
        }
    
        public String getUserName() {
        
            return userName;
        }
    
        public void setUserName(String userName) {
        
            this.userName = userName;
        }
    
        public String getUserAge() {
        
            return userAge;
        }
    
        public void setUserAge(String userAge) {
        
            this.userAge = userAge;
        }
    }

###### 8.3.1.2 序列化对象 ######

package IO流.对象流;
    
    import java.io.FileOutputStream;
    import java.io.ObjectOutputStream;
    
    /**
     * @author 缘友一世
     * date 2022/10/27-17:24
     */
    public class ObjectOutputStreamObjectTypeDemo {
        
        public static void main(String[] args) {
        
            ObjectOutputStream oos=null;
            try {
        
                oos=new ObjectOutputStream(new FileOutputStream("basic grammar/src/IO流/对象流/text2.txt"));
                User user1 = new User(1, "酸梅汤小王子", "18");
                oos.writeObject(user1);
                oos.flush();
            }catch (Exception e) {
        
                e.printStackTrace();
            }finally {
        
                try {
        
                    if(oos!=null) {
        
                        oos.close();
                    }
                }catch (Exception e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

#### 8.3.2 将对象反序列化到内存中 ####

package IO流.对象流;
    
    import java.io.FileInputStream;
    import java.io.ObjectInputStream;
    
    /**
     * @author 缘友一世
     * date 2022/10/27-17:44
     */
    public class ObjectInputStreamObjectTypeDemo {
        
        public static void main(String[] args) {
        
            ObjectInputStream ois=null;
            try {
        
              ois=new ObjectInputStream(new FileInputStream("basic grammar/src/IO流/对象流/text2.txt"));
                User user = (User) ois.readObject();
                System.out.println(user.getUserId()+"\t"+user.getUserName()+"\t"+user.getUserAge());
                
            }catch (Exception e) {
        
                e.printStackTrace();
            }finally {
        
                try{
        
                    if(ois!=null) {
        
                        ois.close();
                    }
                }catch (Exception e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

![在这里插入图片描述][f19dfa66a5ff4b2e944955ec64acf274.png]

## 9 随机访问流 ##

*  ***并不是javaIO流中四大抽象类的子类。它是独立于Java IO包中的一个类。***
 *  RandomAccessFile可以实现两个作用：
    
    1.  ***实现对一个文件做读和写的操作。***
    2.  ***可以访问文件的任意位置。不像其他流只能按照先后顺序读取。***
 *  在开发某些客户端软件时，经常用到这个功能强大的可以”任意操作文件内容”的类。比如，软件的使用次数和使用日期，可以通过本类访问文件中保存次数和日期的地方进行比对和修改。Java很少开发客户端软件，所以在Java开发中这个类用的相对较少。

### 9.1 三个核心方法 ###

1.  `RandomAccessFile(String name，String mode）`
    
     *  name用来确定文件；mode 取r（读）或rw（可读写），通过mode可以确定流对文件的访问权限
2.  seek(long a）用来定位流对象读写文件的位置，a确定读写位置距离文件开头的字节个数。
3.  getFilePointer(）获得流的当前读写位置。

package IO流.随机流;
    
    import java.io.RandomAccessFile;
    
    /**
     * @author 缘友一世
     * date 2022/10/27-18:54
     */
    public class RandomAccessFileDemo {
        
        public static void main(String[] args) {
        
            RandomAccessFile raf=null;
            try {
        
                raf= new RandomAccessFile("basic grammar/src/IO流/随机流/text.txt","rw");
                //将若干数据写入到文件中。
                for(int i=1;i<=10;i++) {
        
                    raf.writeInt(i*10);
                }
                //访问数据 默认为0指向第一个字节
                //跳过四个字节，从第二个数开始读取
                raf.seek(4);
                System.out.println(raf.readInt());
                //隔一个读一个数据
                for(int i=0;i<10;i+=2) {
        
                    raf.seek(i* 4L);
                    System.out.print(raf.readInt()+" ");
                }
                System.out.println();
                System.out.println("==========");
                 //在第8个字节位置插入一个新的数据45，替换之前的数据30
                raf.seek(8);
                raf.writeInt(35);
                for(int i=0;i<10;i+=2) {
        
                    raf.seek(i* 4L);
                    System.out.print(raf.readInt()+" ");
                }
            }catch (Exception e) {
        
                e.printStackTrace();
            }finally {
        
                try {
        
                    if(raf!=null) {
        
                        raf.close();
                    }
                }catch (Exception e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

![在这里插入图片描述][c4970b18e8e54cbb8f5c2bf37bcee247.png]

## 10 FIle类在IO中的作用 ##

*  当有文件作为数据源核目标时。除了可以使用字符串作为文件以及位置的指定以外。也可以使用file类指定。

package IO流;
    
    import java.io.*;
    
    /**
     * @author 缘友一世
     * date 2022/10/27-21:04
     */
    public class FileInIODemo {
        
        public static void main(String[] args) {
        
            BufferedReader br=null;
            BufferedWriter bw=null;
            try {
        
                br=new BufferedReader(new FileReader(new File("basic grammar/src/IO流/write.txt")));
                bw=new BufferedWriter(new FileWriter(new File("basic grammar/src/IO流/write3.txt")));
                int i=1;
                String temp;
                while ((temp=br.readLine())!=null) {
        
                    bw.write(i+":"+temp);
                    bw.newLine();
                    i++;
                }
                bw.flush();
            }catch(Exception e) {
        
                e.printStackTrace();
            }finally {
        
                try {
        
                    if(br!=null) {
        
                        br.close();
                    }if(bw!=null) {
        
                        bw.close();
                    }
                }catch (Exception e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

![在这里插入图片描述][f371b377681c4756949c38c90b1d6e4c.png]

[a5ea1b46655f43b2add79771cfec019b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6214c01a1e524eeabd0b4062a33571d3.png
[f19dfa66a5ff4b2e944955ec64acf274.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/9178424b8d274758824a71bce0f50d58.png
[c4970b18e8e54cbb8f5c2bf37bcee247.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/cfe0238cb2c0447daf238750546d9444.png
[f371b377681c4756949c38c90b1d6e4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/43d7463fb3304aabbb59b4e53c1d5717.png