io流序列化和反序列化

最新推荐文章于 2022-04-12 19:51:06 发布

熊小弟弟弟

最新推荐文章于 2022-04-12 19:51:06 发布

阅读量198

点赞数

本文链接：https://blog.csdn.net/wuzhangxiong123/article/details/108431326

版权

Java文件读写

java文件基本操作

文件类File

常用方法：

方法名	含义
boolean creatNewFile	创建文件
boolean exists	判断文件是否存在
String getAbsolutePath	获取文件的绝对路径
String getName	获取文件名
String getParent	返回此File对象的上一级目录，如果没有上一级目录，则返回null
String getPath	获取文件的路径
String lastModified	获取文件最后的修改时间
boolean mkdir	创建一个目录，它的路径由当前的File对象指定
boolean mkdirs	创建包括父目录的目录

示例

  File file=new File("/Users/beifeng/temp");
        if (!file.exists()){
            file.mkdirs();//mkdir 创建单级目录， mikdirs 创建多级目录
        }
        //isDirectory 检测file是否是目录
        System.out.println("Is file directory\t"+file.isDirectory());
        //创建文件
        File f=new File("/Users/beifeng/temp/abc.txt");
        if (!f.exists()){
            try {
                f.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();//可能因为权限不足或磁盘已满报错
            }
        }
        //输出文件相关属性
        System.out.println("Is f file?\t"+f.isFile());//是否是文件
        System.out.println("name\t"+f.getName());//返回文件名字
        System.out.println("parent\t"+f.getParent());//返回file文件的上级目录
        System.out.println("Path\t"+f.getPath());//返回文件或目录的路径
        System.out.println("Size\t"+f.length()+"bytes");//获取文件或目录的大小
        System.out.println("Last modified time\t"+f.lastModified());//获取文件的最后修改日期
        //遍历temp目录下的所有的文件信息
        System.out.println("list files in file directory");
        File[] fs=file.listFiles();//列出file目录下所有的子文件，但不包括子文件下的目录
        if (fs!=null){
            for(File f1:fs){
                System.out.println(f1.getPath()
                );
            }
        }
//        f.delete();
//        file.delete();

Java7提出的NIO包，提出新的文件系统类

Path，Files，DirectoryStream。FileVisitor，FileSystem

是java.io.File的有益补充。

主要功能有：文件复制和移动文件相对路径递归遍历目录递归删除目录

Path类

  //Path和java.io.File基本类似
        //获得path方法一，
        Path path= FileSystems.getDefault().getPath("/User/beifeng","abc.txt");
        System.out.println(path.getFileName());
        //获得path方法二，用File的toPath（）方法获得path对象
        File file=new File("/User/beifeng/abc.txt");
        Path pathOther=file.toPath();
        System.out.println(path.compareTo(pathOther)); //0，说明这两个path是相等的
        //获得Path方法三
        Path path3= Paths.get("/User/beifeng","abc.txt");
        System.out.println(path3.toString());

Files类

	public static void moveFile() {
		Path from = Paths.get("c:/temp", "abc.txt");
		//移动c:/temp/abc.txt到c:/temp/test/def.txt，如目标文件已存在，就替换
		Path to = from.getParent().resolve("test/def.txt");
		try {
			//文件的大小bytes
			System.out.println(Files.size(from));
			//调用文件移动方法  如果目标文件已经存在，就替换
			Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
		} catch (IOException e) {
			System.err.println("移动文件错误" + e.getMessage());
		}
	}

Java IO包

java读写文件，只能以**（数据）流**的形式进行读写

Java IO包分为三类

-节点类：直接对文件进行操作

InputStream , OutputStream(字节)

子类： FileInputStream， FileOutputStram

Reader,Write(字符)

子类：FileReader，FileWriter

-转化类：字节/字符/数据类型的转化类

字符到字节之间的转化

InputStreamReader：文件读取字节，转化为java能理解的字符

OutputStreamWriter：Java将字符转化为字节输入到文件中

-装饰类：装饰节点类

DataInputStream，DataOutputStream：封装数据流

BufferedInputStream，BufferOuputStream：缓存字节流

BufferedReader，BufferedWriter：缓存字符流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1aow4eSj-1599374071711)(/Users/beifeng/Documents/IO流.png)]

文本文件读写

写文件：

先创建文件，写入数据，关闭文件。

主要用到的类： FileOutputStream，OutputStreamWriter，

BufferedWriter，（write，newLine）

try-resource语句，自动关闭资源。

关闭最外层的数据流，将会把其上的所有数据流都关闭

    public static void writeFile(){
        FileOutputStream fos=null;
        OutputStreamWriter osw=null;
        BufferedWriter bw=null;
        try {
            fos=new FileOutputStream("/Users/beifeng/temp/abc.txt");//找到文件，获取文件节点
            osw=new OutputStreamWriter(fos);//字符和字节流的转换区
            bw=new BufferedWriter(osw);//创建字符缓冲区
            bw.write("我们是");
            bw.newLine();
            bw.write("Ecnume^^");
            bw.newLine();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                bw.close();
            }catch(Exception ex){
                ex.printStackTrace();
            }
        }

    }
		
    public static void write(){
        //try-resource语句，自动关闭资源
        try(BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("/Users/beifeng/temp/abc.txt")))){
                bw.write("welcome");
                bw.newLine();
                bw.write("go home");
                bw.newLine();
        }catch(Exception e){
            e.printStackTrace();
        }

    }

读文件：

先打开文件，逐行读入数据，关闭文件。

主要用到的类： FileInputStream，InputStreamReader，

BufferedReader， (write，newLine）

try-resource语句，自动关闭资源。

关闭最外层的数据流，将会把其上的所有数据流都关闭

public static void reader(){
        FileInputStream fis=null;
        InputStreamReader isr=null;
        BufferedReader br=null;
        try {
            fis = new FileInputStream("/Users/beifeng/temp/abc.txt");
            isr=new InputStreamReader(fis);
            br=new BufferedReader(isr);
            String line;
            while((line=br.readLine())!=null){
                System.out.println(line);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void readerFile(){
        try(BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("/Users/beifeng/temp/abc.txt")))){
                String line;
                while((line=br.readLine())!=null){
                    System.out.println(line);
                }
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }

整理

字节流和字符流区别：

字符流在操作时使用了缓冲区，而字符流在操作时直接操作文件，不会使用缓冲区

/**
 *InputStream、OutputStream、Reader、Writer里都有read方法
 *InputStream OutputStream 都是byte数组
 *Reader是char数组		Writer是String类型
 *
 * read() :  从输入流中读取数据的下一个字节，返回0到255范围内的int字节值。
 * 如果因为已经到达流末尾而没有可用的字节，则返回-1。在输入数据可用、检测到流末尾或者抛出异常前，
 * 此方法一直阻塞。
 *
 * read(byte[] b) :  从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
 * 以整数形式返回实际读取的字节数。在输入数据可用、检测到文件末尾或者抛出异常前，此方法一直阻塞。
 *
 * 如果 b 的长度为 0，则不读取任何字节并返回 0；否则，尝试读取至少一个字节。
 * 如果因为流位于文件末尾而没有可用的字节，则返回值 -1；否则，至少读取一个字节并将其存储在 b 中。
 *
 * read(byte[] b,int off, int length) 从输入流中读取数据，保存到数组b中，保存的位置从off开始
 */

读写二进制文件

写二进制文件

 public static void write(){
        try {
            FileOutputStream fis = new FileOutputStream("/Users/beifeng/temp/jkl.txt");
            BufferedOutputStream bw=new BufferedOutputStream(fis);
            DataOutputStream dis = new DataOutputStream(bw);
            dis.writeByte(1);
            dis.writeLong(2);
            dis.writeChar('a');
            dis.writeUTF("hello");
            dis.flush();
            dis.close();

        }catch(IOException e){
            e.printStackTrace();
        }
    }

读二进制文件

public static void read(){
        try {
            FileInputStream fs = new FileInputStream("/Users/beifeng/temp/jkl.txt");
            BufferedInputStream bis = new BufferedInputStream(fs);
            DataInputStream dis = new DataInputStream(bis);
            System.out.println(dis.readByte());
            System.out.println(dis.readLong());
            System.out.println(dis.readChar());
            System.out.println(dis.readUTF());
            dis.close();

        }catch(IOException e){
            e.printStackTrace();
        }
    }

重定向标准 I/O

System.in 常见方法如下：

int read() ，此方法从接盘接受一个字节的数据，返回值是该字符的ASCII码

int read(byte[] buf)，此方法从键盘接受多个字节的数据，保存至buf中，返回值是接受字节数据的个数，非ASCII码

int read(byte[] buf,int off,int length) 和第二个方法返回值一样，off是开始的位置

System.out 常见方法如下：

print（）

println()

System类提供了三个重定向标准输入/输出的方法

方法	说明
static void setErro( PrintStream err)	重定向标准错误输出流
static void setIn( InputStream in)	重定向标准输入流
static void setOut( OutputStream out)	重定向标准输出流

setOut

public static void setO(){
        try {
            PrintStream ps = new PrintStream(new FileOutputStream("/Users/beifeng/temp/abc.txt"));
            System.setOut(ps);
            System.out.println("我的测试，重定向到文件abc");
        }catch(IOException e){
            e.printStackTrace();
        }
    }

setIn

public static void  getI(){
        try {
            System.setIn(new FileInputStream("/Users/beifeng/temp/abc.txt"));
            byte[] bs=new byte[System.in.available()];
            while(  System.in.read(bs,0,bs.length)!=-1){
                System.out.println(new String(bs));
            }
        }catch(IOException e){
            e.printStackTrace();
        }
    }

序列化和反序列化

一.什么是序列化和反序列化

java序列化是指将java对象转化为字节序列的过程，

java反序列化是指将字节序列回复为java对象的过程。

二.为什么要序列化？

其实我们的对象不只是存储在内存中，它还需要在传输网络中进行传输，并且保存起来下次再加载出来，这时候就需要序列化技术。

一般Java对象的生命周期比Java虚拟机端，而实际开发中如果需要JVM停止后能够继续持有对象，则需要用到序列化技术将对象持久化到磁盘或数据库。
在多个项目进行RPC调用时，需要在网络上传输JavaBean对象，而网络上只允许二进制形式的数据进行传输，这时则需要用到序列化技术。

Java的序列化技术就是把对象转换成一串由二进制字节组成的数组，然后将这二进制数据保存在磁盘或传输网络。而后需要用到这对象时，磁盘或者网络接收者可以通过反序列化得到此对象，达到对象持久化的目的。

意义：序列化机制允许将实现序列化的Java对象转换位字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。
**使用场景：所有可在网络上传输的对象都必须是可序列化的，**比如RMI（remote method invoke,即远程方法调用），传入的参数或返回的对象都是可序列化的，否则会出错；所有需要保存到磁盘的java对象都必须是可序列化的。通常建议：程序创建的每个JavaBean类都实现Serializeable接口。

三.序列化实现的方式

如果需要将某个对象保存到磁盘上或者通过网络传输，那么这个类盖世仙Serializable接口或者Externalizable接口之一。

1.Serializable

Serializable接口是一个标机接口，不用实现任何方法。一旦实现了此接口，该类的对象就是可序列化的。

普通序列化

序列化步骤：

步骤一：创建一个ObjectOutputStream输出流

步骤二：调用ObjectOutputStream对象的writeObject（）输出可序列化的对象

public class Person implements Serializable {
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    public String toString(){
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


public static void main(String[] args) {
        try {//创建一个objectOutputStream输出流
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("/Users/beifeng/temp/def.txt"));
            //将对象序列化到文件中
            Person person=new Person("Logan",20);
            oos.writeObject(person);
        }catch(IOException e){
            e.printStackTrace();
        }

反序列步骤：

步骤一：创建一个ObjectInputStream输入流

步骤二：调用ObjectInputStream对象的readObject（）得到序列化的对象

public static void main(String[] args) {
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/Users/beifeng/temp/def.txt"));
            Person brady=(Person) ois.readObject();
            System.out.println(brady);
        }catch(IOException | ClassNotFoundException e){
            e.printStackTrace();
        }
    }
//输出结果 Person{name='Logan', age=20}

输出告诉我们，反序列化并不会调用构造方法。反序列的对象是JVM生成的对象，并不通过构造方法

成员是引用的序列化

如果一个可序列化的类的成员不是基本类型，也不是String类型，那么这个引用类型也必须是可序列化的，否则会导致此类不能序列化

例如：我们新增一个Teacher类实现Serializable接口。将Person作为Teacher的属性，并将Person去掉实现Serializable接口代码。

我们会看到程序直接报错，yinweiPerson类的对象是不可序列化的，这导致了Teacher对象的不可序列化

同一对象序列化多次的机制

同一对象序列化多次，会将这个对象序列化多次吗？答案是否定的。

public class WriteTeacher {
    public static void main(String[] args) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
            Person person = new Person("路飞", 20);
            Teacher t1 = new Teacher("雷利", person);
            Teacher t2 = new Teacher("红发香克斯", person);
            //依次将4个对象写入输入流
            oos.writeObject(t1);
            oos.writeObject(t2);
            oos.writeObject(person);
            oos.writeObject(t2);
        }
    }
}

依次将t1、t2、person、t2对象序列化到文件teacher.txt文件中。

注意：反序列化的顺序与序列化时的顺序一致。

public class ReadTeacher {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"))) {
            Teacher t1 = (Teacher) ois.readObject();
            Teacher t2 = (Teacher) ois.readObject();
            Person p = (Person) ois.readObject();
            Teacher t3 = (Teacher) ois.readObject();
            System.out.println(t1 == t2);
            System.out.println(t1.getPerson() == p);
            System.out.println(t2.getPerson() == p);
            System.out.println(t2 == t3);
            System.out.println(t1.getPerson() == t2.getPerson());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//输出结果
//false
//true
//true
//true
//true

从输出结果可以看出，Java序列化同一对象，并不会将此对象序列化多次得到多个对象。

序列化算法

1.所有保存到磁盘的对象都有一个序列化编码号。

2.当程序试图序列化一个对象时，会先检查此对象是否已经序列化过，只有此对象从未（在此虚拟机）序列化过，才会将此对象序列化为字节序列输出

3.如果此对象已经序列化过，则直接输出编号即可

如果序列化一个可变对象（对象内的内容可更改）后，更改了对象内容，再次序列化，并不会再次将此对象转换为字节序列，而只是保存序列化编号。

可选的自定义序列化

有些时候，我们有这样的需求，某些属性不需要序列化。使用transient关键字选择不需要序列化的字段。

public class Person implements Serializable {
   //不需要序列化名字与年龄
   private transient String name;
   private transient int age;
   private int height;
   private transient boolean singlehood;
   public Person(String name, int age) {
       this.name = name;
       this.age = age;
   }
   //省略get,set方法
}

public class TransientTest {
   public static void main(String[] args) throws Exception {
       try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
            ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
           Person person = new Person("9龙", 23);
           person.setHeight(185);
           System.out.println(person);
           oos.writeObject(person);
           Person p1 = (Person)ios.readObject();
           System.out.println(p1);
       }
   }
}
//输出结果
//Person{name='9龙', age=23', singlehood=true', height=185cm}
//Person{name='null', age=0', singlehood=false', height=185cm}

从输出我们看到，使用transient修饰的属性，java序列化时，会忽略掉此字段，所以反序列化出的对象，被transient修饰的属性是默认值。对于引用类型，值是null；基本类型，值是0；boolean类型，值是false。

使用transient虽然简单，但将此属性完全隔离在了序列化之外。java提供了**可选的自定义序列化。**可以进行控制序列化的方式，或者对序列化数据进行编码加密等。

private void writeObject(java.io.ObjectOutputStream out) throws IOException；
private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
private void readObjectNoData() throws ObjectStreamException;

通过重写writeObject与readObject方法，可以自己选择哪些属性需要序列化，哪些属性不需要。如果writeObject使用某种规则序列化，则相应的readObject需要相反的规则反序列化，以便能正确反序列化出对象。这里展示对名字进行反转加密。

public class Person implements Serializable {
   private String name;
   private int age;
   //省略构造方法，get及set方法

   private void writeObject(ObjectOutputStream out) throws IOException {
       //将名字反转写入二进制流
       out.writeObject(new StringBuffer(this.name).reverse());
       out.writeInt(age);
   }

   private void readObject(ObjectInputStream ins) throws IOException,ClassNotFoundException{
       //将读出的字符串反转恢复回来
       this.name = ((StringBuffer)ins.readObject()).reverse().toString();
       this.age = ins.readInt();
   }
}

当序列化流不完整时，readObjectNoData()方法可以用来正确地初始化反序列化的对象。例如，使用不同类接收反序列化对象，或者序列化流被篡改时，系统都会调用readObjectNoData()方法来初始化反序列化的对象。

更彻底的自定义序列化

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

writeReplace：在序列化时，会先调用此方法，再调用writeObject方法。此方法可将任意对象代替目标序列化对象

public class Person implements Serializable {
  private String name;
  private int age;
  //省略构造方法，get及set方法

  private Object writeReplace() throws ObjectStreamException {
      ArrayList<Object> list = new ArrayList<>(2);
      list.add(this.name);
      list.add(this.age);
      return list;
  }

   public static void main(String[] args) throws Exception {
      try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
           ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
          Person person = new Person("9龙", 23);
          oos.writeObject(person);
          ArrayList list = (ArrayList)ios.readObject();
          System.out.println(list);
      }
  }
}
//输出结果
//[9龙, 23]

readResolve：反序列化时替换反序列化出的对象，反序列化出来的对象被立即丢弃。此方法在readeObject后调用。

public class Person implements Serializable {
    private String name;
    private int age;
    //省略构造方法，get及set方法
     private Object readResolve() throws ObjectStreamException{
        return new ("brady", 23);
    }
    public static void main(String[] args) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
             ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
            Person person = new Person("9龙", 23);
            oos.writeObject(person);
            HashMap map = (HashMap)ios.readObject();
            System.out.println(map);
        }
    }
}
//输出结果
//{brady=23}

readResolve常用来反序列单例类，保证单例类的唯一性。

注意：readResolve与writeReplace的访问修饰符可以是private、protected、public，如果父类重写了这两个方法，子类都需要根据自身需求重写，这显然不是一个好的设计。通常建议对于final修饰的类重写readResolve方法没有问题；否则，重写readResolve使用private修饰。

四、序列化版本号serialVersionUID

我们知道，反序列化必须拥有class文件，但随着项目的升级，class文件也会升级，序列化怎么保证升级前后的兼容性呢？

java序列化提供了一个private static final long serialVersionUID 的序列化版本号，只有版本号相同，即使更改了序列化属性，对象也可以正确被反序列化回来。

public class Person implements Serializable {
    //序列化版本号
    private static final long serialVersionUID = 1111013L;
    private String name;
    private int age;
    //省略构造方法及get,set
}

如果反序列化使用的class的版本号与序列化时使用的不一致，反序列化会报InvalidClassException异常。

序列化版本号可自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，这样随着class的升级，就无法正确反序列化；不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化。

什么情况下需要修改serialVersionUID呢？分三种情况。

如果只是修改了方法，反序列化不容影响，则无需修改版本号；
如果只是修改了静态变量，瞬态变量（transient修饰的变量），反序列化不受影响，无需修改版本号；
如果修改了非瞬态变量，则可能导致反序列化失败。**如果新类中实例变量的类型与序列化时类的类型不一致，则会反序列化失败，这时候需要更改serialVersionUID。**如果只是新增了实例变量，则反序列化回来新增的是默认值；如果减少了实例变量，反序列化时会忽略掉减少的实例变量。

五、总结

所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口。
对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化。
如果想让某个变量不被序列化，使用transient修饰。
序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。
反序列化时必须有序列化对象的class文件。
当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取。
单例类序列化，需要重写readResolve()方法；否则会破坏单例原则。
同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化。
建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级。

熊小弟弟弟

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
io流序列化和反序列化

Java文件读写java文件基本操作文件类File常用方法：方法名含义boolean creatNewFile创建文件boolean exists判断文件是否存在String getAbsolutePath获取文件的绝对路径String getName获取文件名String getParent返回此File对象的上一级目录，如果没有上一级目录，则返回nullString get
复制链接

扫一扫