【Java】对象序列化与文件的输入输出

最新推荐文章于 2024-03-13 20:40:31 发布
最新推荐文章于 2024-03-13 20:40:31 发布
阅读量349 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qzw752890913/article/details/110149007
版权

文章目录

序列化对象与还原对象

序列化对象

保存对象主要有两种方式，第一种，序列化对象并写入文件；第二种，将对象写入纯文本文件。
我们主要来看第一种：序列化对象。

//Weapon.java
public class Weapon {
}

//GameCharacter.java
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class GameCharacter implements Serializable{
    private int power;
    private String type;
    Weapon[] weapons;

    public Weapon getWeapon() {
        return new Weapon();
    }
    public void useWeapon(){

    }
    public void increasePower(){

    }
    public static void main(String[] args){
        GameCharacter characterOne = new GameCharacter();
        GameCharacter characterTwo = new GameCharacter();
        GameCharacter characterThree = new GameCharacter();

        try {
            FileOutputStream fileStream = new FileOutputStream("MyGame.ser");
            ObjectOutputStream os = new ObjectOutputStream(fileStream);
            os.writeObject(characterOne);
            os.writeObject(characterTwo);
            os.writeObject(characterThree);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • ObjectOutputStream调用writeObject方法，将对象转换成可以写入串流的数据
  • FileOutputStream将字节数据写入文件
  • 对象要被序列化，必须实现Serializable接口
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class Box{
    private int width;
    private int height;
    public void setWidth(int w){
        width = w;
    }
    public void setHeight(int h){
        height = h;
    }
    public static void main(String[] args){
        Box box = new Box();
        box.setWidth(10);
        box.setHeight(20);

        try {
            FileOutputStream fileStream = new FileOutputStream("myBox.ser");
            ObjectOutputStream os = new ObjectOutputStream(fileStream);
            os.writeObject(box);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
实例1:类没有实现Serializable接口导致其实例对象不能被序列化

在这里插入图片描述
类Box必须实现Serializable接口，其实例对象才能被序列化，就像下面这样，

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Box implements Serializable{
    private int width;
    private int height;
    public void setWidth(int w){
        width = w;
    }
    public void setHeight(int h){
        height = h;
    }
    public static void main(String[] args){
        Box box = new Box();
        box.setWidth(10);
        box.setHeight(20);

        try {
            FileOutputStream fileStream = new FileOutputStream("myBox.ser");
            ObjectOutputStream os = new ObjectOutputStream(fileStream);
            os.writeObject(box);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
实例2:对象的实例属性没有实现Serializable接口导致对象不能被序列化
//Duck.java
public class Duck {
}

//Pond.java
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Pond implements Serializable {
    private Duck duck = new Duck();
    public static void main(String[] args){
        Pond pond = new Pond();
        try {
            FileOutputStream fileStream = new FileOutputStream("myPond.ser");
            ObjectOutputStream os = new ObjectOutputStream(fileStream);
            os.writeObject(pond);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述
类实例对象的实例属性必须实现Serializable接口，该对象才能被序列化，就像下面这样，

//Duck.java
import java.io.Serializable;

public class Duck implements Serializable{
}
实例3:将实例变量标识为transient可跳过被实例化
//Dog.java
public class Dog {
}

//Pond.java
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Pond implements Serializable {
    private Duck duck = new Duck();
    private Dog dog = new Dog();
    public static void main(String[] args){
        Pond pond = new Pond();
        try {
            FileOutputStream fileStream = new FileOutputStream("myPond.ser");
            ObjectOutputStream os = new ObjectOutputStream(fileStream);
            os.writeObject(pond);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述
如果不想让实例变量dog被序列化，可以将其标识为transient，就像下面这样，

//Pond.java
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Pond implements Serializable {
    private Duck duck = new Duck();
    private transient Dog dog = new Dog();
    public static void main(String[] args){
        Pond pond = new Pond();
        try {
            FileOutputStream fileStream = new FileOutputStream("myPond.ser");
            ObjectOutputStream os = new ObjectOutputStream(fileStream);
            os.writeObject(pond);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
还原对象

还原对象，也就是解序列化。

//GameCharacter.java
import java.io.Serializable;

public class GameCharacter implements Serializable{
    private int power;
    private String type;

    public GameCharacter(int p,String t){
        power = p;
        type = t;
    }
    public int getPower(){
        return power;
    }
    public String getType(){
        return type;
    }
}

//Test.java
import java.io.*;

public class Test {
    public static void main(String[] args){
        GameCharacter one = new GameCharacter(1,"superman");
        GameCharacter two = new GameCharacter(2,"ironman");
        GameCharacter three = new GameCharacter(3,"caption");
        try {
            FileOutputStream fileOs = new FileOutputStream("myGame.ser");
            ObjectOutputStream os = new ObjectOutputStream(fileOs);
            os.writeObject(one);
            os.writeObject(two);
            os.writeObject(three);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            FileInputStream fileIs = new FileInputStream("myGame.ser");
            ObjectInputStream is = new ObjectInputStream(fileIs);
            GameCharacter one_d = (GameCharacter) is.readObject();
            System.out.println(one_d.getType());
            GameCharacter two_d = (GameCharacter) is.readObject();
            System.out.println(two_d.getType());
            GameCharacter three_d = (GameCharacter) is.readObject();
            System.out.println(three_d.getType());
            is.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • 对象会被当作字节读入
  • Java虚拟机根据存储的信息找到对象类型并加载该对象类型
  • 加载实例变量的存储值
  • 读取对象的顺序与写入对象的顺序相同
    在这里插入图片描述
  • 静态变量为类中所有实例共享，而不是属于某个对象，因此静态变量不会被序列化

读写文件

将字符串写入文本文件
//Test.java
import java.io.FileWriter;
import java.io.IOException;

public class Test {
    public static void main(String[] args){
        try {
            FileWriter writer = new FileWriter("foo.txt");
            writer.write("hello world");
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

//Test.java
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Test {
    public static void main(String[] args){
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("foo.txt"));
            writer.write("hello world");
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

先将数据写入缓冲区，等缓冲区满了之后一并写入文件，从而减少操作磁盘的次数。

从文本文件中读取字符串
  • 新建文件foo.txt
hello world
have a nice day
  • 读取foo.txt中的字符串
//Test.java

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

public class Test {
    public static void main(String[] args){
        File file = new File("foo.txt");
        try {
            BufferedReader reader = new BufferedReader(new FileReader(file));
            String line = null;
            while((line = reader.readLine())!=null){
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

  • 解析字符串
//Test.java

public class Test {
    public static void main(String[] args){
        String str = "What is blue + yellow?/green";
        String[] result = str.split("/");
        for(String token:result){
            System.out.println(token);
        }
    }
}
简单示例
Communication/The Cardigans
Black Dog/Led Zeppelin
Dreams/Van Halen
Comfortably Numb/Pink Floyd
Beth/Kiss
不营业的日常/刘若英

以上是歌单SongList.txt中的内容，每行是“歌名/演唱者”，现在读取这份歌单，将所有歌名加入ArrayList中。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;

public class Test{
    ArrayList<String> list = new ArrayList<String>();
    public static void main(String[] args){
        Test test = new Test();
        test.go();
    }
    public void go(){
        getSongs();
        System.out.println(list);
    }
    public void getSongs(){
        File file = new File("SongList.txt");
        try {
            BufferedReader reader = new BufferedReader(new FileReader(file));
            String line = null;
            while((line=reader.readLine()) != null){
                addSong(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    public void addSong(String line){
        String[] tokens = line.split("/");
        list.add(tokens[0]);
    }
}

在这里插入图片描述

小结

序列化对象还原对象
FileOutputStream fileStream = new FileOutputStream(“MyGame.ser”)FileInputStream fileStream = new FileInputStream(“myGame.ser”)
ObjectOutputStream os= new ObjectOutputStream(fileStream)ObjectInputStream is = new ObjectInputStream(fileStream )
os.writeObject(characterOne)GameCharacter one = (GameCharacter) is.readObject()
os.close()is.close()
写入文本文件读取文本文件
BufferedWriter writer = new BufferedWriter(new FileWriter(“foo.txt”))BufferedReader reader = new BufferedReader(new FileReader(file))
writer.write(“hello world”)reader.readLine()
writer.close()reader.close()
richest_qi
关注
专栏目录
对象序列化控制输入输出
Illus1ion的博客
12-02 699
对象数据是很复杂的，我们可以利用对象序列化来实现 对象序列化是什么 对象序列化(Serialize) 指将一个Java对象写入IO流中，与此对应的是，对象的反序列化(Deserialize) 则指从IO流中恢复该Java对象。如果想让某个Java对象能够序列化，则必须让它的类实现java.io.Serializable 接口 public interface Serializable { } Serializable接口是一个空接口，实现该接口无须实现任何方法，它只是告诉JVM该类可以被序
JAVA对象序列化保存为XML文件的工具类
03-04
【JAVA对象序列化保存为XML文件的工具类】 在Java编程中，对象序列化是一种将对象的状态转换为字节流的过程，以便可以存储或在网络上传输。而在反序列化时，这个字节流又可以恢复为原来的对象。Java提供了一个方便...
java中 使用输入+输出流对对象序列化
梓鸿
12-28 325
java中 使用输入+输出流对对象序列化 对象：注意记得实现 Serializable package com.nf147.sim.entity; import java.io.Serializable; public class News implements Serializable { private int id; ...
Java对象序列化输入输出
weixin_33943347的博客
01-21 130
在网上看到一篇有关于对象序列化的代码，自己仿着写了把 在Java中，entity通过implements Serializable，然后使用ObjectInputStream和ObjectOutputStream把象序列化输入输出 package com.formain.lyy.service.util.serializable; import java.io.Serializabl...
java 如何序列化打印对象_对象序列化控制输入输出
weixin_39825872的博客
02-24 671
前面学习了如何控制基本数据的输入输出，本节主要讲解如何输入输出对象数据。对象数据是很复杂的，我们可以利用对象序列化来实现。对象序列化是什么对象序列化(Serialize)指将一个 Java 对象写入 IO 流中，与此对应的是，对象的反序列化(Deserialize)则指从 IO 流中恢复该 Java 对象。如果想让某个 Java 对象能够序列化，则必须让它的类实现 java.io.Serializ...
java语言序列化与对象输入输出
m0_74957478的博客
06-02 147
二、序列化指把内存中的java对象转换成与平台无关的二进制字节序列，以便永久保存在磁盘上或通过网络进行传输，是java提供的一种将对象写入到输出流并在之后将其读回机制。把java对象转换成字节序列的过程称为对象的序列化，把字节序列恢复为java对象的过程为反序列。一、java提供了对象流ObjectInputStream和ObjectOutputStream，可以将以对象方式存在于内存中的数据存储至文件，需要时在将其从文件中读出还原为对象，或者在网络上传送对象。
深入理解Java对象的序列化与反序列化的应用
09-05
Java对象的序列化和反序列化是Java编程中重要的概念，尤其在数据持久化和网络通信中发挥着关键作用。本文将深入解析这两个过程以及相关的API。 首先，对象的序列化是将Java对象转换为字节序列的过程，以便能够存储...
java 对象输入输出流读写文件的操作实例
08-29
在 Java 中，实现对象序列化和反序列化需要实现 Serializable 接口。Serializable 接口是一个标记接口，实现该接口的类可以被序列化和反序列化。 在本实例中，我们定义了一个名为 Animal 的类，该类实现了 ...
Java对象序列化操作详解
08-27
Java 对象序列化是 Java 语言中一种重要的机制，它允许将 Java 对象转换为字节序列，以便在网络上传送或保存到文件中。对象序列化操作主要有两种用途：把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；...
java中对象的序列化与反序列化深入讲解
08-26
对象序列化是指将Java对象转换为字节序列的过程，而反序列化则是将这些字节序列恢复为原始对象的过程。这一过程对于数据的存储、网络传输以及实现深度克隆等场景具有重要意义。 首先，要实现对象的序列化，Java类...
java 序列化输出过程_输入和输出--java序列化机制
weixin_34748612的博客
02-27 384
对象的序列化什么是Java对象的序列化？对象序列化的目标是将对象保存到磁盘上，或允许在网络中直接传输对象。对象序列化机制允许把内存中的Java对象转换成与平台无关的二进制流，从而保存或者传输。其他的程序一旦获得这种二进制流，还可以把这种二进制流恢复成原来的Java对象序列化是 RMI(Remote Method Invoke – 远程方法调用)过程的参数和返回值都必须实现的机制，而 RMI 是 J...
Java学习（114）Java输入输出流——对象的序列化与反序列化
weixin_43360025的博客
01-20 558
Java学习（114）Java输入输出流——对象的序列化与反序列化
1.10 对象序列化控制输入输出
you can you up up up的博客
09-16 382
对象序列化是什么 对象序列化（Serialize）指将一个 Java 对象写入 IO 流中，与此对应的是，对象的反序列化（Deserialize）则指从 IO 流中恢复该 Java 对象。如果想让某个 Java 对象能够序列化，则必须让它的类实现 java.io.Serializable 接口，接口定义如下： public interface Serializable { } Serializable 接口是一个空接口，实现该接口无须实现任何方法，它只是告诉 JVM 该类可以被序列化机制处理。通常建议程序
Java的对象序列化以及文件IO处理
JonnyWei的专栏
04-16 1489
Java的对象序列化以及文件IO处理
java 对象 序列化 文件中,如何将java序列化对象写入和读取到文件中
weixin_39988331的博客
02-13 158
I am going to write multiple objects to a file and then retrieve them in another part of my code. My code has no error, but it is not working properly. Could you please help me find what is wrong abou...
java如何将序列化对象_如何将一个Java对象序列化到文件里？
weixin_36434531的博客
02-12 239
将对象序列化到文件1)对象需要实现Seralizable接口public class StudentBean implements Serializable {······}2)通过ObjectOutputStream的writeObject()方法写入和ObjectInputStream的readObject()方法来进行读取//存进去try {ObjectOutputStream os = n...
理解对象序列化的文件格式
iteye_15832的博客
04-02 206
理解对象序列化的文件格式？ 先占个题目先，回宿舍研究。
Java对象的序列化和反序列化
最新发布
flytalei的博客
03-13 942
参与序列化和反序列化的对象，必须实现Serializable接口，没有实现该接口时，报错“NotSerializableException”但该接口中什么代码也没有，它只是一个标识，标识给JVM看的。一次序列化多个对象时，参与序列化的ArrayList集合以及集合中的对象User都需要实现“java.io.Serializable”ArrayList源码中已经实现了Serializable接口。如果不指定版本号，当代码后期有修改，修改之后再重新编译就会由如下报错，提示序列化版本不一致。
java 序列化文件_Java将对象写入文件读出_序列化与反序列化的实例
weixin_36201438的博客
02-12 206
Java类中对象的序列化工作是通过ObjectOutputStream和ObjectInputStream来完成的。写入：File aFile=new File("e:\\c.txt");Stu a=new Stu(1, "aa", "1");FileOutputStream fileOutputStream=null;try {fileOutputStream = new FileOutputS...
Java对象序列化与文件输入/输出详解
在《Head First Java》这本书的第14章中，作者详细介绍了Java中的对象序列化和文件输入/输出，这是进行持久化存储数据的关键技术。对象序列化允许我们将Java对象转换为字节流，以便存储到磁盘上或在网络中传输。这样...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值