IO流的使用之保存对象信息（java日志十四）

最新推荐文章于 2023-06-28 22:39:51 发布

奕羿

最新推荐文章于 2023-06-28 22:39:51 发布

阅读量553

点赞数 5

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/cr18175627706/article/details/130975560

版权

文章目录

前言
方法1：序列化
方法2：文本格式保存对象
总结

前言

最近应老师要求，做一个商品管理系统，既然是商品管理系统，那就需要储存使用者和商品的信息，我是用类数组的形式来实现它的，可是，有一个问题，Java类数组存储在计算机的堆内存中(~~如果它是对象的一个成员变量，引用本身存储在栈上，对象本身储存在堆上~~)。堆内存在程序运行时被分配给Java虚拟机，但使用后并且由Java垃圾回收器负责清理不再使用的内存空间。

这也就意味着，我所储存的信息并未写在电脑的硬盘上，我这个程序一旦执行完了，储存的信息也就随之消失，显然，这并不是我所期待的，那么有没有一种方法可以将内容写进硬盘呢？？当然是有的IO流就可以去实现，但是有一个问题困扰我很久，如果用IO去做的话，如何去处理对象，如何对对象的内容进行增删改查的操作，同时要将数据保存在文档中。这里提供两种方法。

提示：以下是本篇文章正文内容，下面案例可供参考

方法1：序列化

一、将类序列化

1.Serializable

一个类想要可以被序列化，需要实现Serializable这个接口。
打开这个接口的源码，发现空空如也，

public interface Serializable {
}

其中注解中有这么一句：

/*
 Serializability of a class is enabled by the class implementing the java.io.Serializable interface.
 Classes that do not implement this interface will not have any of their state serialized or deserialized.
 All subtypes of a serializable class are themselves serializable. 
 The serialization interface has no methods or fields and serves only to identify the semantics of being serializable.
 类的可序列化性由实现java.io.Serializable接口的类来启用。
 未实现此接口的类将不会序列化或反序列化其任何状态。
 可序列化类的所有子类本身都是可序列化的。
 序列化接口没有方法或字段，仅用于标识可序列化的语义。
 */

我们可以由此知道，这个接口无需实现任何方法，其作用是为了标识这个类所对应的对象可以被序列化。这类接口也称为标记接口。

2.serialVersionUID

凡是实现Serializable接口的类都有一个标识标识符序列化版本的标识符常量serialVersionUID，如果说你自己没有定义一个，那么系统会给你自动生成一个。

 public  static final long serialVersionUID=12345678L;

你需要确保的是serialVersionUID必须是唯一的。
建议自己声明一个，因为当类的属性被修改后默认生成的serialVersionUID也会随之改变。
如果再去读的话，会发生类似以下的不相容异常：

 People; local class incompatible: 
 stream classdesc serialVersionUID = 12345678, 
 local class serialVersionUID = -5002263540498840000

如果自定义serialVersionUID无论那个类被修改成了什么模样，都可以被read。

3.transient

序列化时忽视transient修饰的字段，不对其进行序列化。

二、使用ObjectInputStream和ObjectOutputStream

ObjectOutputStream 的方法：

void writeObject(Object obj): 将指定的对象进行序列化并写入输出流。
void write(int b): 将一个字节写入输出流。
void write(byte[] b): 将字节数组写入输出流。
void write(byte[] b, int off, int len): 将字节数组的一部分写入输出流。
- b - 要写入的字节数组。
- of - 起始偏移量。
- en - 要写入的字节数。
void flush(): 刷新输出流，确保缓冲区中的数据被立即写入目标流。
void close(): 关闭输出流。

ObjectInputStream 的方法：

Object readObject(): 从输入流中读取一个对象，并进行反序列化。
int read(): 从输入流中读取一个字节，如果已到达流的末尾，则返回 -1。
int read(byte[] b): 从输入流中读取字节数组，实际读取的字节数，如果已到达流的末尾，则返回 -1。
int read(byte[] b, int off, int len): 从输入流中读取字节数组的一部分，如果已到达流的末尾，则返回 -1。
-b - 存储读取数据的字节数组。
- off - 起始偏移量。
- en - 要读取的最大字节数。
void close(): 关闭输入流。

这些方法是 ObjectOutputStream 和 ObjectInputStream 类中的常用方法。根据具体的需求，可以选择适当的方法来进行对象的序列化和反序列化操作。

这是我们操作的类

import java.io.Serializable;

public class User implements Serializable {
    public  static final long serialVersionUID=12345678L;
    private String name;
    private int age;
    public User() {
    }
    public User(String name, int age) {
        this.name = name;
        this.age=age;
    }
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    public String getMessage(){
        return  "name:"+this.name+"\nage:"+this.age;
    }
}

让我们来看看怎么具体操作：
将对象写进文件

import java.io.*;
import java.util.ArrayList;
import java.io.IOException;
public class Main {
    public static void main(String[] args) {
        ArrayList<User> users=new ArrayList<>();
        File f=new File("C:\\Users\\user\\Desktop\\CONTENT.txt");
        User user1=new User("小帅",18);
        User user2=new User("小美",18);
        User user3=new User("小卡拉米",28);
        users.add(user1);
        users.add(user2);
        users.add(user3);
        write(f,users);
    }
    public static void write(File f,ArrayList<User> users){
        OutputStream os=null;
        ObjectOutputStream oos=null;
        try {
            os = new FileOutputStream(f);
            oos = new ObjectOutputStream(os);
            for(User user:users) {
                oos.writeObject(user);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(oos!=null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os!=null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

让我们打开CONTENT.txt文档看看里面的内容：
在这里插入图片描述
读不懂，一坨乱码，转换为16进制看看：

我们可以看见一些对象信息，比如User,name,age…具体是什么我也不知道，期待大佬解释。

将文件中的对象读取出来

public class Main {
    public static void main(String[] args) {
        File f=new File("C:\\Users\\user\\Desktop\\CONTENT.txt");
        ArrayList<User> users1=read(f);
        for(User user:users1){
            System.out.println(user.getMessage());
        }
    }
    public static ArrayList<User> read(File f){
        InputStream fis=null;
        ObjectInputStream ois=null;
        ArrayList<User> users=new ArrayList<>();
        try {
            fis=new FileInputStream(f);
            ois=new ObjectInputStream(fis);
            while (true) {
                try {
                    Object user = ois.readObject();
                    users.add((User) user);
                } catch (EOFException e) {
                    // 文件读取到末尾，退出循环
                    break;
                }
            }
        }catch (IOException|ClassNotFoundException e){
            e.printStackTrace();
        }finally {
            if(ois!=null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis!=null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return users;
    }
}

在这里插入图片描述
显然读取成功

方法2：文本格式保存对象

我们将一个对象的数据写到一个txt文档中，要怎么去做才能让对象之间的数据不混淆，清晰可读呢，这里将进行介绍。

一.将对象数据写进文本

PrintWriter

我们这里用PrintWriter去写，PrintWriter中有一个public void println(String x) 方法，打印一个字符串，后面跟着一个终止符，我们调用println方法去写，每行写一个对象，对象信息用“|”去隔离，至于为什么这么做，稍后再讲
这是我们操作的类

public class User {
    private String name;
    private int age;
    public User() {
    }
    public User(String name, int age) {
        this.name = name;
        this.age=age;
    }
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    public String getMessage(){
        return  "name:"+this.name+"\nage:"+this.age;
    }
}

public static void write(File f, ArrayList<User> users) {
        PrintWriter pw = null;
        try {
            pw = new PrintWriter(f);
            for (User user : users) {
                pw.println(user.getName() + "|" + user.getAge());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (pw != null) {
                pw.close();
                //close以被包装，不必检查
            }
        }
    }

close的源码：

public void close() {
        try {
            synchronized (lock) {
                if (out == null)
                    return;
                out.close();
                out = null;
            }
        }
        catch (IOException x) {
            trouble = true;
        }
    }

我们运行一下：

public static void main(String[] args) {
        ArrayList<User> user=new ArrayList<>();
        File f=new File("C:\\Users\\user\\Desktop\\CONTENT.txt");
        User user1=new User("小帅",18);
        User user2=new User("小美",18);
        user.add(user1);
        user.add(user2);
        write(f,user);
    }

运行结束后，我们打开CONTENT.txt文件看看里面的内容
在这里插入图片描述
显然对象信息已经成功写入进去了。

二.读取文档数据

1.File中的readAllLines方法

这是他的源码：

    public static List<String> readAllLines(Path path, Charset cs) throws IOException {
        try (BufferedReader reader = newBufferedReader(path, cs)) {
            List<String> result = new ArrayList<>();
            for (;;) {
                String line = reader.readLine();
                if (line == null)
                    break;
                result.add(line);
            }
            return result;
        }
    }

Java 中 java.nio.file.Files 类提供的一个便捷方法，用于读取文本文件的所有行内容，并将其存储在一个 List<String> 集合中。每行的内容为集合的一个元素。

我们再看参数，有Path path和Charset cs

Path

在Java中，Path 类是用于表示文件系统中的路径的类。它提供了一种统一的方式来处理文件路径。

它可以用于创建和解析路径：Path 类提供了多种静态方法和实例方法来创建和解析文件路径。你可以使用这些方法来创建绝对路径或相对路径，以及解析文件路径中的组成部分（目录、文件名等）。

例如：

import java.nio.file.Path;
import java.nio.file.Paths;
public class Main {
    public static void main(String[] args) {
        // 创建路径
        Path path1 = Paths.get("C:\\mydir\\myfile.txt");
        Path path2 = Paths.get("C:", "mydir", "myfile.txt");
    }
}

需要注意的是，Path 类只是用于表示路径，并提供了一些对路径进行操作的方法，它并不执行实际的文件系统操作。如果你需要执行与文件系统相关的操作，如读取文件内容或写入文件，可以使用其他类，如 Files 类提供的方法。

Charset

在计算机编程中，Charset（字符集）是用于表示字符编码的标准集合。它定义了字符和字节之间的映射关系，用于在字符数据和字节数据之间进行转换。

字符编码是一种将字符表示为字节序列的方式，以便在计算机系统中存储、传输和处理文本数据。不同的字符编码方案使用不同的字符集来表示字符，其中每个字符都有一个对应的唯一的编码值。

常见的字符编码包括 UTF-8、UTF-16、ISO-8859-1 等。

2.String中的split方法

打开源码查看它的介绍：

    public String[] split(String regex) {
        return split(regex, 0);
    }

//        Splits this string around matches of the given regular expression.
//        This method works as if by invoking the two-argument split method with the given expression and a limit argument of zero.
//        Trailing empty strings are therefore not included in the resulting array.
//        围绕给定正则表达式的匹配拆分此字符串。
//        此方法的工作方式类似于使用给定表达式和极限参数为0调用双参数split方法。
//        因此，尾随的空字符串不包含在结果数组中。

split() 方法是 Java 中 String 类的一个常用方法，用于将字符串按指定的分隔符拆分成多个子字符串，并返回一个字符串数组。

其中，regex 是一个正则表达式，用于指定字符串的分隔符。分隔符可以是一个简单的字符串，也可以是一个复杂的正则表达式。split() 方法返回的是一个字符串数组，每个元素都是原始字符串中的一个子字符串。如果原始字符串为空，或者无法找到匹配的分隔符，则返回一个只包含原始字符串的数组。

split() 方法的工作原理如下：

它将调用者字符串按照指定的分隔符进行拆分。
拆分后的子字符串将作为数组元素存储在返回的字符串数组中。

下面是一些示例用法：

使用空格作为分隔符拆分字符串：

String str = "Hello World";
String[] parts = str.split(" ");
// parts = ["Hello", "World"]

使用逗号作为分隔符拆分字符串：

String str = "Apple, Banana, Orange";
String[] fruits = str.split(",");
// fruits = ["Apple", " Banana", " Orange"]
// 注意：空格也被包含在了拆分的子字符串中，可以使用 trim() 方法去除空格

使用正则表达式作为分隔符拆分字符串：

String str = "One1Two2Three3Four";
String[] parts = str.split("\\d+");
// parts = ["One", "Two", "Three", "Four"]
// 正则表达式 "\\d+" 表示匹配一个或多个数字

让我们来看看怎么用这个方法去读取对象信息：

public static ArrayList<User> read(File f){
        String filePath = f.getPath();
        ArrayList<User> user=new ArrayList<>();
        try {
        Path path = Paths.get(filePath);
        List<String> content = Files.readAllLines(path, StandardCharsets.UTF_8);
        for(String str:content){
            String[] stock=str.split("\\|");
            String name=stock[0];
            int age=Integer.parseInt(stock[1]);
            User user1=new User(name,age);
            user.add(user1);
        }
        }catch (IOException e){
            e.printStackTrace();
        }
        return user;
    }

测试一下：

public static void main(String[] args) {
         ArrayList<User> user=new ArrayList<>();
         File f=new File("C:\\Users\\user\\Desktop\\CONTENT.txt");
          ArrayList<User> users= read(f);
          for(User use:users){
              System.out.println(use.getMessage());
          }
    }

在这里插入图片描述
显然，读取对象信息成功。

总结

以上就是今天要讲的内容，本文仅仅简单介绍如何保存对象数据。

方法1：序列化
一、将类序列化：1.Serializable 2.serialVersionUID3.transient
二、使用ObjectInputStream和ObjectOutputStream

方法2：文本格式保存对象
一.将对象数据写进文本 PrintWriter
二.读取文档数据1.File中的readAllLines方法 2.String中的split方法

奕羿

关注

5
点赞
踩
1

收藏

觉得还不错? 一键收藏
3
评论
IO流的使用之保存对象信息（java日志十四）

本文仅仅简单介绍如何保存对象数据。方法1：序列化一、将类序列化：1.Serializable 2.serialVersionUID3.transient二、使用ObjectInputStream和ObjectOutputStream方法2：文本格式保存对象一.将对象数据写进文本 PrintWriter二.读取文档数据1.File中的readAllLines方法 2.String中的split方法
复制链接

扫一扫