【C#/Java】【小白必看】不要只会读写文本文件了！对象序列化助你提高效率

【C#/Java】【小白必看】不要只会读写文本文件了！对象序列化助你提高效率

? 在编程的世界里，文件的读写操作是我们经常面对的任务之一。
? 当我们只涉及简单的文本文件时，这个任务似乎并不复杂。但是，当我们处理更为复杂的类对象时，逐个字段进行读取和写入会显得非常繁琐。更为严峻的是，当类的字段发生变化时，我们需要同时修改读取和写入模块，而且还要考虑与原有版本文件的兼容性。

1. 为什么需要对象序列化？

? 在面对复杂的类结构时，逐个字段进行读取和写入是非常不便利的。这种方式容易导致代码的冗长和维护的困难。而对象序列化则能够将整个对象保存到文件中，不仅减少了代码量，还提高了代码的可维护性。此外，对象序列化还能够解决不同版本之间的兼容性问题，使得在类结构发生变化时，我们仍然能够正确地读取旧版本的文件。

例子：个人信息的存取

? 设想一下，当我们开发一个系统时，需要对个人信息进行保存。刚开始只有用户名、密码、邮箱，可随着系统越来越完善，所含有的变量也越来越多，这时候如果还是按照原有的思路，一个变量一个变量进行读写，很有可能产生遗漏，且代码庞杂不美观。

? 我们以一个包含多个字段的PersonalInfo类为例，展示逐个字段读写和对象序列化之间的对比。

以C#为例：

首先，我们看一下逐个字段读写的示例：

using System;
using System.Diagnostics;
using System.IO;

class Program
{
    class PersonalInfo
    {
        public string UserName { get; set; }
        public string Email { get; set; }
        public string Password { get; set; }
        public int Level { get; set; }
        public string Avatar { get; set; }
        public string Signature { get; set; }
        // ... 可能还有其他字段 ...
    }

    static void Main()
    {
        PersonalInfo person = new PersonalInfo
        {
            UserName = "JohnDoe",
            Email = "john@example.com",
            Password = "securepassword",
            Level = 3,
            Avatar = "avatar.jpg",
            Signature = "Hello, world!"
            // ... 其他字段的初始化 ...
        };

        Stopwatch stopwatch = new Stopwatch();

        // 逐个字段写入
        using (StreamWriter writer = new StreamWriter("person.txt"))
        {
            stopwatch.Start();
            writer.WriteLine(person.UserName);
            writer.WriteLine(person.Email);
            writer.WriteLine(person.Password);
            writer.WriteLine(person.Level);
            writer.WriteLine(person.Avatar);
            writer.WriteLine(person.Signature);
            // ... 其他字段的写入 ...
            stopwatch.Stop();
        }

        Console.WriteLine($"逐个字段写入耗时：{stopwatch.ElapsedMilliseconds} 毫秒");

        // 重新初始化 PersonalInfo 对象
        person = new PersonalInfo();

        // 逐个字段读取
        using (StreamReader reader = new StreamReader("person.txt"))
        {
            stopwatch.Restart();
            person.UserName = reader.ReadLine();
            person.Email = reader.ReadLine();
            person.Password = reader.ReadLine();
            person.Level = int.Parse(reader.ReadLine());
            person.Avatar = reader.ReadLine();
            person.Signature = reader.ReadLine();
            // ... 其他字段的读取 ...
            stopwatch.Stop();
        }

        Console.WriteLine($"逐个字段读取耗时：{stopwatch.ElapsedMilliseconds} 毫秒");
    }
}

接下来，我们看一下对象序列化的示例：

using System;
using System.Diagnostics;
using System.IO;
using Newtonsoft.Json;

class Program
{
    class PersonalInfo
    {
        public string UserName { get; set; }
        public string Email { get; set; }
        public string Password { get; set; }
        public int Level { get; set; }
        public string Avatar { get; set; }
        public string Signature { get; set; }
        // ... 可能还有其他字段 ...
    }

    static void Main()
    {
        PersonalInfo person = new PersonalInfo
        {
            UserName = "JohnDoe",
            Email = "john@example.com",
            Password = "securepassword",
            Level = 3,
            Avatar = "avatar.jpg",
            Signature = "Hello, world!"
            // ... 其他字段的初始化 ...
        };

        Stopwatch stopwatch = new Stopwatch();

        // 对象序列化
        stopwatch.Start();
        string json = JsonConvert.SerializeObject(person);
        File.WriteAllText("person.json", json);
        stopwatch.Stop();
        Console.WriteLine($"对象序列化耗时：{stopwatch.ElapsedMilliseconds} 毫秒");

        // 重新初始化 PersonalInfo 对象
        person = new PersonalInfo();

        // 对象反序列化
        stopwatch.Restart();
        string jsonString = File.ReadAllText("person.json");
        PersonalInfo deserializedPerson = JsonConvert.DeserializeObject<PersonalInfo>(jsonString);
        stopwatch.Stop();
        Console.WriteLine($"对象反序列化耗时：{stopwatch.ElapsedMilliseconds} 毫秒");
    }
}

? 通过上述例子，我们可以清晰地看到，使用对象序列化的代码更加简洁、清晰，并且不需要关心逐个字段的读写细节。

? 特别是在处理大型复杂对象时，对象序列化的优势更为明显。这种方式可以提高代码的可读性，减少冗余操作，并确保在类结构发生变化时仍能正确处理文件的读写操作。

2. C#中的对象序列化

? 在C#中，我们常用的对象序列化工具是Newtonsoft.Json。该工具提供了强大而灵活的功能，使得对象序列化变得异常简单。下面通过一个例子来说明：

// 定义一个示例类
public class PersonalInfo
{
    public string UserName { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
    public int Level { get; set; }
    public string Avatar { get; set; }
    public string Signature { get; set; }
    // ... 其他字段 ...
}

// 对象序列化示例
PersonalInfo person = new PersonalInfo
{
    UserName = "JohnDoe",
    Email = "john@example.com",
    Password = "securepassword",
    Level = 3,
    Avatar = "avatar.jpg",
    Signature = "Hello, world!"
    // ... 其他字段的初始化 ...
};

string json = JsonConvert.SerializeObject(person);
File.WriteAllText("person.json", json);

// 对象反序列化示例
string jsonString = File.ReadAllText("person.json");
PersonalInfo deserializedPerson = JsonConvert.DeserializeObject<PersonalInfo>(jsonString);

3. Java中的对象序列化

? 在Java中，我们使用Object流来实现对象的序列化。下面是一个简单的Java示例：

import java.io.*;

// 定义一个示例类
class PersonalInfo implements Serializable {
    String userName;
    String email;
    String password;
    int level;
    String avatar;
    String signature;
    // ... 其他字段 ...

    // 构造函数
    public PersonalInfo(String userName, String email, String password, int level, String avatar, String signature) {
        this.userName = userName;
        this.email = email;
        this.password = password;
        this.level = level;
        this.avatar = avatar;
        this.signature = signature;
        // ... 其他字段的初始化 ...
    }
}

// 对象序列化示例
PersonalInfo person = new PersonalInfo("JohnDoe", "john@example.com", "securepassword", 3, "avatar.jpg", "Hello, world!");

try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
    oos.writeObject(person);
}

// 对象反序列化示例
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
    PersonalInfo deserializedPerson = (PersonalInfo) ois.readObject();
}

4.结语

? 通过以上示例，我们清晰地展示了对象序列化的威力。在处理类结构较为庞大的情况下，对象序列化能够使代码更加简洁、可读性更强，同时保证了不同版本之间的兼容性。不妨尝试使用对象序列化，提高你的代码效率，让读写操作变得更加轻松！