Java-转换流和对象操作流

左手的ㄟ右手 2022-12-26 10:14 183阅读 0赞

### 文章目录 ###

*  一、转换流
 *   *  1.字符流中和编码解码相关的两个类
     *  2.转换流构造方法
     *  3.转换流代码实例
 *  二、对象操作流
 *   *  1.对象序列化流
     *   *  （1）对象序列化流概述
         *  （2）对象序列化流的方法
         *  （3）对象序列化流代码实例
         *  （4）对象序列化流的注意事项
     *  2.对象反序列化流
     *   *  （1）对象反序列化流概述
         *  （2）对象反序列化流的方法
         *  （3）对象反序列化流代码实例
     *  3.serialVersionUID&transient
     *  4.对象操作流程代码实例

--------------------

# 一、转换流 #

JKD11之前

## 1.字符流中和编码解码相关的两个类 ##

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

## 2.转换流构造方法 ##

<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 charset)</td> 
   <td>使用指定的字符编码创建OutputStreamWriter对象</td> 
  </tr> 
 </tbody> 
</table>

## 3.转换流代码实例 ##

import java.io.*;
    
    public class Csdn {
        
        public static void main(String[] args) throws IOException {
        
            OutputStreamWriter osw = new OutputStreamWriter(new
                    FileOutputStream("a.txt"), "GBK");
            osw.write("中国");
            osw.close();
            InputStreamReader isr = new InputStreamReader(new
                    FileInputStream("a.txt"), "GBK");
            int ch;
            while ((ch = isr.read()) != -1){
        
                System.out.print((char) ch);
            }
            isr.close();
        }
    }

> 中国

JDK11开始字符流也同样可以指定读写的字符编码

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>FileReader(String fileName, Charset charset)</td> 
   <td>在给定从中读取数据的File的情况下创建一个新FileReader</td> 
  </tr> 
  <tr> 
   <td>FileWriter(String fileName, Charset charset)</td> 
   <td>在给定从中读取数据的File的情况下创建一个新FileWriter</td> 
  </tr> 
 </tbody> 
</table>

import java.io.*;
    import java.nio.charset.Charset;
    
    public class Csdn {
        
        public static void main(String[] args) throws IOException {
        
            FileWriter fw = new FileWriter("a.txt", Charset.forName("GBK"));
            fw.write("中国");
            fw.close();
            FileReader fr = new FileReader("a.txt", Charset.forName("GBK"));
            int ch;
            while ((ch = fr.read()) != -1){
        
                System.out.print((char) ch);
            }
            fr.close();
        }
    }

> 中国

# 二、对象操作流 #

## 1.对象序列化流 ##

### （1）对象序列化流概述 ###

对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象。

这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息；字节序列写到文件之后，相当于文件中持久保存了一个对象的信息；反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。

对象序列化流： ObjectOutputStream

*  将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取（重构）对象。 可以通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象。

### （2）对象序列化流的方法 ###

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

### （3）对象序列化流代码实例 ###

import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Csdn {
        
        public static void main(String[] args) throws IOException {
        
            ObjectOutputStream oos = new ObjectOutputStream(new
                    FileOutputStream("a.txt"));
            Student s = new Student("浮华", 20);
            oos.writeObject(s);
            oos.close();
        }
    }
    
    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 +
                    '}';
        }
    }

### （4）对象序列化流的注意事项 ###

*  一个对象要想被序列化，该对象所属的类必须必须实现Serializable 接口
 *  Serializable是一个标记接口，实现该接口，不需要重写任何方法

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

### （1）对象反序列化流概述 ###

对象反序列化流： ObjectInputStream

*  ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象

### （2）对象反序列化流的方法 ###

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

### （3）对象反序列化流代码实例 ###

import java.io.*;
    
    public class Csdn {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException {
        
            ObjectInputStream ois = new ObjectInputStream(new
                    FileInputStream("a.txt"));
            Object obj = ois.readObject();
            Student s = (Student) obj;
            System.out.println(s.getName() + "," + s.getAge());
            ois.close();
        }
    }
    
    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 +
                    '}';
        }
    }

> 浮华,20

## 3.serialVersionUID&transient ##

serialVersionUID

*  用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？

> 会出问题，会抛出InvalidClassException异常

如果出问题了，如何解决呢？

*  重新序列化
 *  给对象所属的类加一个serialVersionUID

private static final long serialVersionUID = 42L;

transient

*  如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？

> 给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程

## 4.对象操作流程代码实例 ##

*  需求  
    创建多个学生类对象写到文件中,再次读取到内存中
 *  实现步骤
    
    1.  创建序列化流对象
    2.  创建多个学生对象
    3.  将学生对象添加到集合中
    4.  将集合对象序列化到文件中
    5.  创建反序列化流对象
    6.  将文件中的对象数据,读取到内存中

import java.io.*;
    import java.util.ArrayList;
    
    public class Csdn {
        
        public static void main(String[] args) throws Exception {
        
            ObjectOutputStream oos = new ObjectOutputStream(new
                    FileOutputStream("a.txt"));
            ArrayList<Student> arrayList = new ArrayList<>();
            Student s00 = new Student("浮华", 20);
            Student s01 = new Student("浮华", 30);
            arrayList.add(s00);
            arrayList.add(s01);
            oos.writeObject(arrayList);
            oos.close();
    
            ObjectInputStream ois = new ObjectInputStream(new
                    FileInputStream("a.txt"));
            Object obj = ois.readObject();
            ArrayList<Student> arrayList1 = (ArrayList<Student>) obj;
            ois.close();
            for (Student s : arrayList1) {
        
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }
    
    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;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

--------------------