转换流、对象操作流、Properties集合相关知识点及其案例

布满荆棘的人生 2023-10-07 21:19 108阅读 0赞

#### 文章目录 ####

*  前言
 *  转换流
 *   *  字符流中和编码解码问题相关的两个类
     *  转换流读写数据
 *  对象操作流
 *   *  对象序列化流
     *  对象反序列化流
     *  serialVersionUID&transient
     *  对象操作流练习
 *  Properties集合
 *   *  Properties 作为 Map集合的使用
     *  Properties 作为 Map 集合的特有方法
     *  Properties 和 IO 流相结合的方法
     *  Properties 集合练习

## 前言 ##

当我们学习完输入流和输出流后，我们都知道，当我们往本地文件中写入 97 98 99时，本地文件中会写入 a b c，同样，我们在读取时，读取到的也是字符所对应的字节，那么字节和字符是如何转换的呢?下面我们来学习IO流中的转换流

## 转换流 ##

### 字符流中和编码解码问题相关的两个类 ###

*  InputStreamReader
    
        是从字节流到字符流的桥梁，父类是 Reader 它读取字节，并使用指定的
         编码将其解码为字符
         它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台
         的默认字符集
 *  OutputStreamWriter
    
        是从字符流到字节流的桥梁，父类是 Writer ,使用指定的编码将写入的字符
         编码为字节，它使用的字符集可以由名称指定，也可以被明确指定，或者可以
         接受平台的默认字符集

### 转换流读写数据 ###

*  构造方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>InputStreamReader(InputStream in)</td> 
   <td>使用默认字符编码创建 InputStreamReader 对象</td> 
  </tr> 
  <tr> 
   <td>InputStreamReader(InputStream in,String chatset)</td> 
   <td>使用指定的字符编码创建 InputStreamReader 对象</td> 
  </tr> 
  <tr> 
   <td>OutputStreamWriter(OutputStream out)</td> 
   <td>使用默认字符编码创建 OutputStreamWriter 对象</td> 
  </tr> 
  <tr> 
   <td>OutputStreamWriter(OutputStream out,String chatset)</td> 
   <td>使用指定的字符编码创建 OutputStreamWriter 对象</td> 
  </tr> 
 </tbody> 
</table>

*  代码演示

package com.hcx;
    
    import java.io.*;
    
    public class Demo9 {
        
        public static void main(String[] args) throws IOException {
        
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("osw.txt"),"gbk");
            outputStreamWriter.write("中国");
    
            outputStreamWriter.close();
    
            InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("osw.txt"), "gbk");
    
            //一次读取一个数据
            int ch;
            while((ch=inputStreamReader.read())!= -1){
        
                System.out.println((char)ch);
            }
                inputStreamReader.close();
    
        }
    }

*  使用 gbk 字符编码将数据写到 osw.txt 文件中  
    ![在这里插入图片描述][eb5d2e047d0b4316a8ac46ff1e4d8caa.png]
 *  使用 gbk 字符编码读取 osw.txt 文件中的数据  
    ![在这里插入图片描述][e467188ec11e408bb64928ce015aca6d.png]
 *  图解  
    ![在这里插入图片描述][0987c2e2aaa7440eb2a327ed9168e937.png]

## 对象操作流 ##

### 对象序列化流 ###

*  对象序列化介绍
    
     *  对象序列化：就是将对象保存在磁盘中，或者在网络中传输对象
     *  这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
     *  字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
     *  反之，该字节序列还可以从文件中读取出来，重构对象，对它进行反序列化
 *  对象序列化流:ObjectOutputStream
    
     *  将 Java 对象的原始数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。可以通过使用流的文件夹实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象
 *  构造方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ObjectOutStream(OutputStream out)</td> 
   <td>创建一个写入指定的 OutputStream 的 ObjectOutputStream</td> 
  </tr> 
 </tbody> 
</table>

*  序列化对象的方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void writeObject(Object obj)</td> 
   <td>将指定的对象写入 ObjectOutputStream</td> 
  </tr> 
 </tbody> 
</table>

*  示例代码
    
     *  学生类

package com.hcx;
    
    import java.io.Serializable;
    
    public class Student implements Serializable {
        
        private String name;
        private int age;
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

*  测试类

package com.hcx;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    
    public class ObjectOutputStreamDemo {
        
        public static void main(String[] args) throws IOException {
        
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("oos.txt"));
                //创建对象
            Student s = new Student("佟丽娅", 30);
            //将指定的对象写入 ObjectOutputStream
            objectOutputStream.writeObject(s);
            //关闭资源
            objectOutputStream.close();
        }
    }

*  运行程序后，oos.txt 文件中的内容  
    ![在这里插入图片描述][5ee924dda4e343c58a7d756349af756b.png]  
    注意：  
    1.一个对象要想被序列化，该对象所属的类必须实现 Serializable 接口  
    2.Serializable 是一个标记接口，实现该接口，不需要重写任何方法

### 对象反序列化流 ###

*  对象反序列化流： ObjectInputStream
    
     *  ObjectInputStream 反序列化优先使用 ObjectOutStream 编写的原始数据和对象
 *  构造方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ObjectInputStream(InputStream in)</td> 
   <td>创建从指定的 InputStream 读取的 ObjectInputStream</td> 
  </tr> 
 </tbody> 
</table>

*  反序列化对象的方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Object readObject()</td> 
   <td>从 ObjectInputStream 读取一个对象</td> 
  </tr> 
 </tbody> 
</table>

*  示例代码

package com.hcx;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    
    public class ObjectInputStreamDemo {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException {
        
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("oos.txt"));
    
            //从 ObjectInputStream 读取一个对象
            Object obj = objectInputStream.readObject();
    
            Student s =(Student) obj;
            System.out.println(s.getName()+","+s.getAge());
    
            objectInputStream.close();
    
        }
    }

*  控制台输出  
    ![在这里插入图片描述][8272cac1688f431abe92be799759e61c.png]

### serialVersionUID&transient ###

*  serialVersionUID
    
     *  用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出现问题呢？
        
         *  会出问题，会抛出 InvalidClassException异常  
            ![在这里插入图片描述][21f1dabf7795408ba4d7272366de0481.png]
     *  如果出现问题，如何解决呢？
        
         *  重新序列化  
            ![在这里插入图片描述][052b634796fd42959efd9b205b87d296.png]
         *  给对象所属的类加一个 serialVersionUID
            
             *  private static final long serialVersionUID=42L  
                ![在这里插入图片描述][4abd0e677f614f148669de29c9aec342.png]
 *  transient
    
     *  如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
        
         *  给该成员变量加 transient 修饰,该关键字标记的成员变量不参与序列化过程。
 *  示例代码  
    学生类

package com.hcx;
    
    import java.io.Serializable;
    
    public class Student implements Serializable {
        
        private static final long serialVersionUID=42L;
        private String name;
        private transient int age;
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

测试类

package com.hcx;
    
    import java.io.*;
    
    public class ObjectInputStreamDemo {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException {
        
            write();
            read();
    
    
        }
    
        //序列化
        private static void write() throws IOException {
        
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("oos.txt"));
            Student s = new Student("佟丽娅",30);
            objectOutputStream.writeObject(s);
            objectOutputStream.close();
        }
    
        //反序列化
        private static void read() throws IOException, ClassNotFoundException {
        
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("oos.txt"));
    
            //从 ObjectInputStream 读取一个对象
            Object obj = objectInputStream.readObject();
    
            Student s =(Student) obj;
            System.out.println(s.getName()+","+s.getAge());
    
            objectInputStream.close();
        }
    
    
    }

*  控制台输出  
    ![在这里插入图片描述][e12357f8e8a546d5ba3686feff4f9479.png]

### 对象操作流练习 ###

*  案例需求  
    创建多个学生类对象写到文件中，再次读取到内存中
 *  实现步骤
    
     *  创建序列化流对象
     *  创建多个学生对象
     *  将学生对象添加到集合中
     *  将集合对象序列化到文件中
     *  创建反序列化流对象
     *  将文件中的对象数据，读取到内存中
 *  代码实现  
    学生类

package com.hcx;
    
    import java.io.Serializable;
    
    public class Student implements Serializable {
        
        private static final long serialVersionUID=2L;
        private String name;
        private  int age;
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    }

测试类

package com.hcx;
    
    import java.io.*;
    import java.util.ArrayList;
    
    public class Demo10 {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException {
        
            //1.创建序列化流对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("oos.txt"));
    
            ArrayList<Student> list = new ArrayList<>();
            //2.创建多个学生对象
            Student student1 = new Student("佟丽娅",30);
            Student student2 = new Student("李明",24);
            //3.将学生对象添加到集合中
             list.add(student1);
             list.add(student2);
             //4.将集合对象序列化到文件中
                objectOutputStream.writeObject(list);
                objectOutputStream.close();
    
                //反序列化
            //5.创建反序列化流对象
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("oos.txt"));
            //6.将文件中的对象数据，读取到内存中
            Object object = objectInputStream.readObject();
            ArrayList<Student> list1 = (ArrayList<Student>) object;
            objectInputStream.close();
            for (Student s:list1) {
        
                System.out.println(s.getName()+","+s.getAge());
            }
    
        }
    }

*  控制台输出  
    ![在这里插入图片描述][9d6cdc27ed80418aa8dde63c60995d34.png]

## Properties集合 ##

### Properties 作为 Map集合的使用 ###

*  Properties 介绍
    
     *  是一个 Map 体系的集合类
     *  Properties 可以保存到流中或从流中加载
     *  属性列表中的每个键及其对应的值都是一个字符串
 *  Properties基本使用

package com.hcx;
    
    import java.util.Properties;
    import java.util.Set;
    
    public class PropertiesDemo1 {
        
        public static void main(String[] args) {
        
            //创建集合对象
    
            Properties properties = new Properties();
    
            //存储元素
            properties.put("001","佟丽娅");
            properties.put("002","赵丽颖");
            properties.put("003","刘诗诗");
    
            //遍历集合
    
            Set<Object> keySet = properties.keySet();
            for (Object key: keySet) {
        
                Object value = properties.get(key);
                System.out.println(key +","+value);
            }
        }
    }

*  控制台输出  
    ![在这里插入图片描述][28f8dd7eaddc408ab5b4ff003833369c.png]

### Properties 作为 Map 集合的特有方法 ###

*  特有方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Object setProperty(String key,String value)</td> 
   <td>设置集合的键和值，都是 String 类型，底层调用 Hashtable 方法 put</td> 
  </tr> 
  <tr> 
   <td>String getProperty(String key)</td> 
   <td>使用此属性列表中指定的键搜索属性</td> 
  </tr> 
  <tr> 
   <td>Set stringPropertyNames()</td> 
   <td>从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串</td> 
  </tr> 
 </tbody> 
</table>

*  示例代码

package com.hcx;
    
    import java.util.Properties;
    import java.util.Set;
    
    public class PropertiesDemo2 {
        
        public static void main(String[] args) {
        
            //创建集合对象
            Properties properties = new Properties();
            //设置集合的键和值，都是 String 类型
            properties.setProperty("001","张三");
            properties.setProperty("002","李四");
            properties.setProperty("003","王五");
    
            //使用此属性列表中指定的键搜索值
            System.out.println(properties.getProperty("001"));
            System.out.println(properties.getProperty("002"));
    
            //从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
            Set<String> names = properties.stringPropertyNames();
            for (String key:
                 names) {
        
                String value = properties.getProperty(key);
                System.out.println(key+"," + value);
    
            }
    
        }
    }

*  控制台输出  
    ![在这里插入图片描述][ba7e4e2718874bfe8b8e5b80f8a3bcba.png]

### Properties 和 IO 流相结合的方法 ###

*  和 IO 流结合的方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void load(Reader reader)</td> 
   <td>从输入字符流读取属性列表（键和元素对）</td> 
  </tr> 
  <tr> 
   <td>void store(Writer writer,String comments)</td> 
   <td>将此属性列表（键和元素对）写入此 Properties 表中，以适合使用 load(Reader) 方法的格式写入输出字符流</td> 
  </tr> 
 </tbody> 
</table>

*  示例代码

package com.hcx;
    
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.Properties;
    
    public class PropertiesDemo3 {
        
        public static void main(String[] args) throws IOException {
        
            //把集合中的数据保存到文件
            Properties properties = new Properties();
            properties.setProperty("001","张三");
            properties.setProperty("002","李四");
            properties.setProperty("003","王五");
    
            FileWriter fileWriter = new FileWriter("fw.txt");
            properties.store(fileWriter,null);
            fileWriter.close();
        }
    }

*  运行成功后 fw.txt 文件中的内容  
    ![在这里插入图片描述][9d8408bb59d741759b3387f0ffec9da1.png]

package com.hcx;
    
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.Properties;
    
    public class PropertiesDemo4 {
        
        public static void main(String[] args) throws IOException {
        
        //将文件中的数据加载到集合
            Properties properties = new Properties();
            FileReader fileReader = new FileReader("fw.txt");
            properties.load(fileReader);
            fileReader.close();
            System.out.println(properties);
    
        }
    }

*  控制台输出  
    ![在这里插入图片描述][88eb18b0829040c4bbeeb0f5245244e1.png]

### Properties 集合练习 ###

*  案例需求  
    在 properties 文件中手动写上姓名和年龄，读取到集合中，将该数据封装成学生对象，写到本地文件
 *  实现步骤
    
     *  创建 Properties 集合，将本地文件中的数据加载到集合中
     *  获取集合中的键值对数据，封装到学生对象中
     *  创建序列化流对象，将学生对象序列化到本地文件中
 *  代码实现  
    学生类

package com.hcx;
    
    import java.io.Serializable;
    
    public class Student implements Serializable {
        
        private static final long serialVersionUID=1L;
        private String name;
        private  int age;
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

测试类

package com.hcx;
    
    import java.io.*;
    import java.util.Properties;
    
    public class Test {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException {
        
            //1.创建Properties集合，将本地文件中的数据加载到集合中
            Properties properties = new Properties();
            FileReader fileReader = new FileReader("prop.properties");
            properties.load(fileReader);
            fileReader.close();
            //2.获取集合中的键值对数据，封装到学生对象中
            String name = properties.getProperty("name");
            int age = Integer.parseInt(properties.getProperty("age"));
            Student student = new Student(name,age);
            //3.创建序列化流对象，将学生对象序列化到本地文件
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("a.txt"));
            objectOutputStream.writeObject(student);
            objectOutputStream.close();
    
            //反序列化，读取 a.txt文件内容
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("a.txt"));
            Object object = objectInputStream.readObject();
            objectInputStream.close();
            System.out.println(object);
    
    
        }
    }

*  prop.properties 文件中手写的内容  
    ![在这里插入图片描述][7dfc781fecef444db4e4248c5472c4c4.png]
 *  运行成功，a.txt文件中序列化的内容  
    ![在这里插入图片描述][b44903ebcbf043528f85634287d7930d.png]
 *  反序列化读取后控制台输出  
    ![在这里插入图片描述][7637cad6c81c4b598bbd88f4ef6121e3.png]

[eb5d2e047d0b4316a8ac46ff1e4d8caa.png]: https://img-blog.csdnimg.cn/eb5d2e047d0b4316a8ac46ff1e4d8caa.png
[e467188ec11e408bb64928ce015aca6d.png]: https://img-blog.csdnimg.cn/e467188ec11e408bb64928ce015aca6d.png
[0987c2e2aaa7440eb2a327ed9168e937.png]: https://img-blog.csdnimg.cn/0987c2e2aaa7440eb2a327ed9168e937.png
[5ee924dda4e343c58a7d756349af756b.png]: https://img-blog.csdnimg.cn/5ee924dda4e343c58a7d756349af756b.png
[8272cac1688f431abe92be799759e61c.png]: https://img-blog.csdnimg.cn/8272cac1688f431abe92be799759e61c.png
[21f1dabf7795408ba4d7272366de0481.png]: https://img-blog.csdnimg.cn/21f1dabf7795408ba4d7272366de0481.png
[052b634796fd42959efd9b205b87d296.png]: https://img-blog.csdnimg.cn/052b634796fd42959efd9b205b87d296.png
[4abd0e677f614f148669de29c9aec342.png]: https://img-blog.csdnimg.cn/4abd0e677f614f148669de29c9aec342.png
[e12357f8e8a546d5ba3686feff4f9479.png]: https://img-blog.csdnimg.cn/e12357f8e8a546d5ba3686feff4f9479.png
[9d6cdc27ed80418aa8dde63c60995d34.png]: https://img-blog.csdnimg.cn/9d6cdc27ed80418aa8dde63c60995d34.png
[28f8dd7eaddc408ab5b4ff003833369c.png]: https://img-blog.csdnimg.cn/28f8dd7eaddc408ab5b4ff003833369c.png
[ba7e4e2718874bfe8b8e5b80f8a3bcba.png]: https://img-blog.csdnimg.cn/ba7e4e2718874bfe8b8e5b80f8a3bcba.png
[9d8408bb59d741759b3387f0ffec9da1.png]: https://img-blog.csdnimg.cn/9d8408bb59d741759b3387f0ffec9da1.png
[88eb18b0829040c4bbeeb0f5245244e1.png]: https://img-blog.csdnimg.cn/88eb18b0829040c4bbeeb0f5245244e1.png
[7dfc781fecef444db4e4248c5472c4c4.png]: https://img-blog.csdnimg.cn/7dfc781fecef444db4e4248c5472c4c4.png
[b44903ebcbf043528f85634287d7930d.png]: https://img-blog.csdnimg.cn/b44903ebcbf043528f85634287d7930d.png
[7637cad6c81c4b598bbd88f4ef6121e3.png]: https://img-blog.csdnimg.cn/7637cad6c81c4b598bbd88f4ef6121e3.png