Java 开发篇+一个简单的数据库管理系统ZDB

news2024/11/28 15:54:04

说明：本文供数据库爱好者和初级开发人员学习使用
标签：数据库管理系统、RDBMS、Java小程序、Java、Java程序
系统：Windows 11 x86
CPU ：Intel
IDE ：IntelliJ IDEA Community Edition 2024
语言：Java语言
标准：JDK 17
提示：如果您发现本文哪里写的有问题或者有更好的写法请留言或私信我进行修改优化

★ 程序界面

★ 相关文章

✔ C语言 开发篇+一个简单的数据库管理系统ZDB
✔ C++ 开发篇+一个简单的数据库管理系统ZDB
 

★ 功能简介

目前该Java小程序实现了RDBMS上表的几个基础功能，如：
✔ DDL：create、drop、alter、truncate、flashback、rename、purge
✔ DML：insert、delete、update、select

★ 程序特点

✔ 程序会在首次运行时在同级创建一个数据文件和一个字典文件
✔ 程序运行期间表数据存储在内存中，类似于Redis
✔ 程序运行结束时会将表数据采用序列化和反序列化方式存取
✔ 程序采用List集合实现表中行和列的动态调整
✔ 程序采用Set 集合实现表集合（表空间）大小的动态调整
✔ 程序采用Map 集合实现数据库参数集合的动态调整
✔ 表在drop后purge前支持闪回，purge后相关空间会被清理
✔ 表记录在删除后只是标记为删除，方便后期复用并减少数据shrink的性能消化

★ 程序试用

https://download.csdn.net/download/zzt_2009/89102377

★ 使用案例

############【欢迎使用 ZDB】############
# 语言：Java 17          IDE：IntelliJ #
# 作者：zzt_2009         版本：V 7.0.0 #
# 主页：https://blog.csdn.net/zzt_2009 #
# [H/h]查看帮助          [E/e]退出程序 #
字典文件不存在，初始化中……
字典落盘成功
数据文件不存在，初始化中……
数据落盘成功
首次使用，将为您展示帮助信息：
# L  ：列出所有表的信息     > 案例：L T0                #
# C  ：创建表并指定列名     > 案例：C T0 ID NAME        #
# D  ：删除表（支持闪回） 	> 案例：D T0                #
# A  ：修改表的所有列名     > 案例：A T0 IDS NAMES      #
# R  ：重命名表的名称       > 案例：R T0 T00            #
# T  ：清空表中的数据       > 案例：T T0                #
# F  ：闪回被删除的表       > 案例：F T0_$0             #
# P  ：清空被删除的表       > 案例：P                   #
# i  ：往表中插入1行数据    > 案例：i T0 122 Traffic    #
# d  ：从表中删除1行数据    > 案例：d T0 3              #
# u  ：更新表中的1行数据    > 案例：u T0 3 122 Traffic  #
# s  ：查看表中的有效数据   > 案例：s T0                #
# S  ：查看表中的所有数据   > 案例：S T0                #
# c  ：清理屏幕             > 案例：c                   #
# H/h：查看帮助信息         > 案例：h                   #
# E/e：退出程序             > 案例：e                   #
SQL > L
表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
对象的nextvalue：2
状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
SQL > C T2 ID NAME
表 T2 创建成功。
字典落盘成功
数据落盘成功
表名: T2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
对象的nextvalue：3
状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
SQL > C T3 ID NAME COMMENT
表 T3 创建成功。
字典落盘成功
数据落盘成功
表名: T2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
对象的nextvalue：4
状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
SQL > D T2
表 T2 删除成功。
字典落盘成功
数据落盘成功
表名: T2_$2	编号: 2	状态: 3	Rows: 0	Cols: 2 [ ID/NAME/ ]
表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
对象的nextvalue：4
状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
SQL > F T2_$2
表 T2_$2 已被恢复。
字典落盘成功
数据落盘成功
表名: T2_$2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
对象的nextvalue：4
状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
SQL > R T2_$2 T2
表 T2_$2 更名为 T2 成功。
字典落盘成功
数据落盘成功
表名: T2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
对象的nextvalue：4
状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
SQL > s T0
行号：0	数据：[H, TEL, NAME]
行号：1	数据：[A, 110, police]
行号：2	数据：[A, 120, ambulance]
行号：3	数据：[A, 119, fire]
SQL > d T0 2
相关行数据已删除。
字典落盘成功
数据落盘成功
行号：0	数据：[H, TEL, NAME]
行号：1	数据：[A, 110, police]
行号：2	数据：[A, 119, fire]
SQL > S T0
行号：0	数据：[H, TEL, NAME]
行号：1	数据：[A, 110, police]
行号：2	数据：[D, 120, ambulance]
行号：3	数据：[A, 119, fire]
SQL > i T0 122 car
0 / H
1 / A
2 / D
数据插入表 T0 成功。
字典落盘成功
数据落盘成功
行号：0	数据：[H, TEL, NAME]
行号：1	数据：[A, 110, police]
行号：2	数据：[A, 122, car]
行号：3	数据：[A, 119, fire]
SQL > u T0 2 120 doctor
数据更新成功。
字典落盘成功
数据落盘成功
行号：0	数据：[H, TEL, NAME]
行号：1	数据：[A, 110, police]
行号：2	数据：[A, 120, doctor]
行号：3	数据：[A, 119, fire]
SQL > T T0
表 T0 已被截断。
字典落盘成功
数据落盘成功
表名: T2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
表名: T0	编号: 0	状态: 2	Rows: 0	Cols: 2 [ TEL/NAME/ ]
表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
对象的nextvalue：4
状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
SQL > S T0
行号：0	数据：[H, TEL, NAME]
SQL > e
字典落盘成功
数据落盘成功
#########【感谢使用 ZDB 再见!】#########

★ 程序源码

package zdb_default;

import java.io.*;
import java.util.*;

// 字典类（程序较为简单为了减少文件切换使用内部类方式）
class Class_Dict implements Serializable { // 实现 Serializable 接口，这是进行对象序列化和反序列化所必需的。
    private static final long serialVersionUID = 1L; // 为了在版本升级时保持版本的兼容性，在序列化类中添加 serialVersionUID
    public int value;       //值
    public String comment;  //描述

    // 添加构造函数和getter/setter方法（如果需要）
    public Class_Dict(int value, String comment) {
        this.value = value;
        this.comment = comment;
    }

    // 如果需要，还可以添加toString方法
    @Override
    public String toString() {
        return "Class_Dict{" +
                "value=" + value +
                ", comment='" + comment + '\'' +
                '}';
    }
}

// 表类（程序较为简单为了减少文件切换使用内部类方式）
class Class_Table implements Serializable { // 实现 Serializable 接口，这是进行对象序列化和反序列化所必需的。
    private static final long serialVersionUID = 1L; // 为了在版本升级时保持版本的兼容性，在序列化类中添加 serialVersionUID
    public int id;            // 序号
    public int state;         // 状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
    public String name;       // 名称
    public int oid;           // 对象编号
    public int rows;          // 行数
    public int cols;          // 列数
    public List<List<String>> record = new ArrayList<>(); // 数据&状态："">未分配、H>字段名、A>可用、D>删除
}

public class Class_Main {
    // 定义常量
    private static final String DICT_FILE = "ZDB.dic";
    private static final String DATA_FILE = "ZDB.dat";
    // 创建一个Set集合来存储Class_Dict对象（参数）
    private static Map<String, Class_Dict> dicts = new HashMap<>();
    // 创建一个Set集合来存储Class_Table对象（表）
    private static Set<Class_Table> tables = new HashSet<>();

    public static void main(String[] args) {
        // 显示头信息
        printHead();
        // 从文件中读取字典信息到集合中
        readDicts();
        // 从文件中读取表信息到集合中
        tables = readTables();
        // 读取输入
        while (true) {
            String table_name;
            System.out.print("SQL > ");
            Scanner scanner = new Scanner(System.in);
            String command = scanner.nextLine();
            String[] tokens = command.split(" ");
            String operation = tokens[0];
            switch (operation) {
                case "C": // 创建新表，用法：C T0 id name
                    createTable(tokens);
                    break;
                case "D": // 删除表，用法：D T0
                    dropTable(tokens);
                    break;
                case "A": // 修改表列名，用法：A T0 new_id new_name
                    alterTable(tokens);
                    break;
                case "R": // 重命名表，用法：R T0 T00
                    renameTable(tokens);
                    break;
                case "T": // 清空表数据，用法：T T0
                    truncateTable(tokens);
                    break;
                case "F": // 闪回删除的表，用法：F T0
                    flashbackTable(tokens);
                    break;
                case "P": // 清空所有已删除的表，用法：P
                    purgeTables();
                    break;
                case "L": // 列出库中所有表名和其基础信息，用法：L
                    listTables();
                    break;
                case "i": // 往表插入数据，用法：i T0 1 a 2 b 3 c
                    insertTable(tokens);
                    break;
                case "d": // 删除表中第N行数据，用法：d T0 N
                    deleteTable(tokens);
                    break;
                case "u": // 更新表中第N行数据，用法：u T0 N 1 a
                    updateTable(tokens);
                    break;
                case "s": // 查询表中所有可见数据，用法：s T0
                    selectTable(tokens);
                    break;
                case "S": // 查询表中所有数据，用法：S T0
                    selectAllTable(tokens);
                    break;
                case "c": // 清理屏幕并重新显示printHead()
                    printHead();
                    break;
                case "h": //
                case "H": //
                    printHelp();
                    break;
                case "e": //
                case "E": //
                    writeDicts();
                    writeTables();
                    printEnd();
                    System.exit(0);
                default:
                    System.out.println("命令不正确请重新输入，或按[H/h]查看帮助");
                    break;
            }
        } //循环结束
    } //main_end


    public static void createTable(String[] tokens) {
        if (tokens.length < 3) {
            System.out.println("输入有误，案例：C T0 ID NAME");
            return;
        }
        String tableName = tokens[1];
        for (Class_Table table : tables) {
            if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
                System.out.println("表 " + tableName + " 已存在。");
                return;
            }
        }
        Class_Table newTable = new Class_Table();
        newTable.state = 1;
        newTable.name = tableName;
        newTable.oid = dicts.get("noid").value;
        newTable.rows = 0;
        newTable.cols = (tokens.length - 2);
        dicts.put("noid", new Class_Dict((dicts.get("noid").value + 1), "对象编号的nextvalue"));
        List<String> header = new ArrayList<>();
        header.add("H");
        header.addAll(Arrays.asList(tokens).subList(2, tokens.length));
        newTable.record.add(header);
        tables.add(newTable);
        System.out.println("表 " + tableName + " 创建成功。");
        writeDicts();
        writeTables();
        listTables();
    }

    public static void dropTable(String[] tokens) {
        if (tokens.length != 2) {
            System.out.println("输入有误，案例：D T0");
            return;
        }
        String tableName = tokens[1];
        boolean found = false;
        for (Class_Table table : tables) {
            if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
                table.state = 3;
                table.name = table.name + "_$" + table.oid;
                found = true;
                break;
            }
        }
        if (found) {
            System.out.println("表 " + tableName + " 删除成功。");
            writeDicts();
            writeTables();
            listTables();
        } else {
            System.out.println("表 " + tableName + " 不存在或已被删除。");
        }
    }

    public static void renameTable(String[] tokens) {
        if (tokens.length != 3) {
            System.out.println("命令错误，请检查参数数量。");
            return;
        }
        String oldName = tokens[1];
        String newName = tokens[2];
        for (Class_Table table : tables) {
            if ((table.name.equals(oldName)) && ((table.state == 1) || (table.state == 2))) {
                table.name = newName;
                System.out.println("表 " + oldName + " 更名为 " + newName + " 成功。");
                writeDicts();
                writeTables();
                listTables();
                return;
            }
        }
        System.out.println("表 " + oldName + " 不存在。");
    }

    public static void alterTable(String[] tokens) {
        if (tokens.length < 3) {
            System.out.println("输入有误，案例：A T0 new_col1 new_col2");
            return;
        }
        String tableName = tokens[1];
        for (Class_Table table : tables) {
            if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
                if ((tokens.length - 2) == table.cols) {
                    List<String> header = new ArrayList<>();
                    header.add("H");
                    header.addAll(Arrays.asList(tokens).subList(2, tokens.length));
                    table.record.set(0, header);
                    writeDicts();
                    writeTables();
                    listTables();
                } else {
                    System.out.println("新列数量须和旧列数量一致！");
                }
                return;
            }
        }
        System.out.println("表 " + tableName + " 不存在。");
    }


    public static void truncateTable(String[] tokens) {
        if (tokens.length != 2) {
            System.out.println("输入有误，案例：T T0");
            return;
        }
        String tableName = tokens[1];
        boolean tableFound = false;
        for (Class_Table table : tables) {
            if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
                tableFound = true;
                List<String> header = table.record.get(0);
                table.record.clear();
                table.rows = 0;
                table.record.add(header);
                System.out.println("表 " + tableName + " 已被截断。");
                writeDicts();
                writeTables();
                listTables();
                break;
            }
        }
        if (!tableFound) {
            System.out.println("表 " + tableName + " 不存在。");
        }
    }

    public static void flashbackTable(String[] tokens) {
        if (tokens.length != 2) {
            System.out.println("输入有误，案例：F T0");
            return;
        }
        String tableName = tokens[1];
        boolean tableFound = false;
        for (Class_Table table : tables) {
            if (table.name.equals(tableName) && table.state == 3) {
                tableFound = true;
                if (table.rows == 0) {
                    table.state = 1;
                } else {
                    table.state = 2;
                }
                System.out.println("表 " + tableName + " 已被恢复。");
                writeDicts();
                writeTables();
                listTables();
                break;
            }
        }
        if (!tableFound) {
            System.out.println("表 " + tableName + " 不存在或未被删除。");
        }
    }

    public static void purgeTables() {
        tables.removeIf(table -> table.state == 3);
        System.out.println("所有标记为删除的表已清除。");
    }

    public static void listTables() {
        tables.forEach(table -> {
            System.out.print("表名: " + table.name + "\t");
            System.out.print("编号: " + table.oid + "\t");
            System.out.print("状态: " + table.state + "\t");
            System.out.print("Rows: " + table.rows + "\t");
            System.out.print("Cols: " + table.cols + " ");
            System.out.print("[ ");
            for (int i = 1; i < table.record.get(0).size(); i++) {
                System.out.print(table.record.get(0).get(i) + "/");
            }
            System.out.println(" ]");
        });
        System.out.println("对象的nextvalue：" + dicts.get("noid").value);
        System.out.println("状态：0>未分配、1>新表、2>有数、3>删除、4>可复用");
    }

    public static void insertTable(String[] tokens) {
        if (tokens.length < 3) {
            System.out.println("输入有误，案例：i T0 911 fire");
            return;
        }
        String tableName = tokens[1];
        for (Class_Table table : tables) {
            if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
                if ((tokens.length - 2) == table.cols) {
                    for (int i = 0; i < table.record.size(); i++) {
                        System.out.println(i + " / " + table.record.get(i).get(0));
                        if (Objects.equals(table.record.get(i).get(0), "D")) {
                            List<String> rowData = new ArrayList<>();
                            rowData.add(0, "A");
                            rowData.addAll(Arrays.asList(tokens).subList(2, tokens.length));
                            table.record.set(i, rowData);
                            table.rows++;
                            System.out.println("数据插入表 " + tableName + " 成功。");
                            writeDicts();
                            writeTables();
                            selectTable(("X " + tableName).split(" "));
                            return;
                        }
                    }
                    List<String> rowData = new ArrayList<>();
                    rowData.add(0, "A");
                    rowData.addAll(Arrays.asList(tokens).subList(2, tokens.length));
                    table.record.add(rowData);
                    table.rows++;
                    System.out.println("数据插入表 " + tableName + " 成功。");
                    writeDicts();
                    writeTables();
                    selectTable(("X " + tableName).split(" "));
                } else {
                    System.out.println("列数量不一致！");
                }
                return;
            }
        }
        System.out.println("表 " + tableName + " 不存在。");
    }

    public static void deleteTable(String[] tokens) {
        if (tokens.length != 3) {
            System.out.println("输入有误，案例：d T0 1");
            return;
        }
        String tableName = tokens[1];
        String rowNumber = tokens[2];
        int irowNumber = Integer.parseInt(rowNumber);
        boolean tableFound = false;
        for (Class_Table table : tables) {
            if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
                if ((irowNumber != 0) && (irowNumber <= table.rows)) {
                    tableFound = true;
                    table.record.get(irowNumber).set(0, "D");
                    table.rows--;
                    System.out.println("相关行数据已删除。");
                    writeDicts();
                    writeTables();
                    selectTable(("X " + tableName).split(" "));
                    return;
                } else {
                    System.out.println("不可操作的行号。");
                    return;
                }
            }
        }
        if (!tableFound) {
            System.out.println("表 " + tableName + " 不存在。");
        }
    }

    public static void updateTable(String[] tokens) {

        if (tokens.length < 4) {
            System.out.println("输入有误，案例：u T0 1 110 police");
            return;
        }
        String tableName = tokens[1];
        String rowNumber = tokens[2];
        int irowNumber = Integer.parseInt(rowNumber);
        boolean tableFound = false;
        for (Class_Table table : tables) {
            if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
                tableFound = true;
                if (table.record.get(irowNumber).get(0).equals("A")) {
                    if ((tokens.length - 3) == table.cols) {
                        List<String> rowData = new ArrayList<>();
                        rowData.add(0, "A");
                        rowData.addAll(Arrays.asList(tokens).subList(3, tokens.length));
                        table.record.set(irowNumber, rowData);
                        System.out.println("数据更新成功。");
                        writeDicts();
                        writeTables();
                        selectTable(("X " + tableName).split(" "));
                    } else {
                        System.out.println("列数量不一致！");
                    }
                    return;
                }
            }
        }
        if (!tableFound) {
            System.out.println("表 " + tableName + " 不存在。");
        }
    }

    public static void selectTable(String[] tokens) {
        if (tokens.length != 2) {
            System.out.println("输入有误，案例：s T0");
            return;
        }
        String tableName = tokens[1];
        boolean tableFound = false;
        for (Class_Table table : tables) {
            if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
                tableFound = true;
                int i = 0;
                for (List<String> row : table.record) {
                    if ((row.get(0).equals("H")) || (row.get(0).equals("A"))) {
                        System.out.println("行号：" + i + "\t数据：" + row);
                        i++;
                    }
                }
                break;
            }
        }
        if (!tableFound) {
            System.out.println("表 " + tableName + " 不存在。");
        }
    }


    public static void selectAllTable(String[] tokens) {
        if (tokens.length != 2) {
            System.out.println("输入有误，案例：s T0");
            return;
        }
        String tableName = tokens[1];
        boolean tableFound = false;
        for (Class_Table table : tables) {
            if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
                tableFound = true;
                int i = 0;
                for (List<String> row : table.record) {
                    System.out.println("行号：" + i + "\t数据：" + row);
                    i++;
                }
                break;
            }
        }
        if (!tableFound) {
            System.out.println("表 " + tableName + " 不存在。");
        }
    }

    public static void printHead() {
        try {
            new ProcessBuilder("cmd", "/c", "cls").inheritIO().start().waitFor();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("############【欢迎使用 ZDB】############");
        System.out.println("# 语言：Java 17          IDE：IntelliJ #");
        System.out.println("# 作者：zzt_2009         版本：V 7.0.0 #");
        System.out.println("# 主页：https://blog.csdn.net/zzt_2009 #");
        System.out.println("# [H/h]查看帮助          [E/e]退出程序 #");
    }

    public static void printEnd() {
        System.out.println("#########【感谢使用 ZDB 再见!】#########");
    }

    public static void printHelp() {
        System.out.println("# L  ：列出所有表的信息     > 案例：L T0                #");
        System.out.println("# C  ：创建表并指定列名     > 案例：C T0 ID NAME        #");
        System.out.println("# D  ：删除表（支持闪回）   > 案例：D T0                #");
        System.out.println("# A  ：修改表的所有列名     > 案例：A T0 IDS NAMES      #");
        System.out.println("# R  ：重命名表的名称       > 案例：R T0 T00            #");
        System.out.println("# T  ：清空表中的数据       > 案例：T T0                #");
        System.out.println("# F  ：闪回被删除的表       > 案例：F T0_$0             #");
        System.out.println("# P  ：清空被删除的表       > 案例：P                   #");
        System.out.println("# i  ：往表中插入1行数据    > 案例：i T0 122 Traffic    #");
        System.out.println("# d  ：从表中删除1行数据    > 案例：d T0 3              #");
        System.out.println("# u  ：更新表中的1行数据    > 案例：u T0 3 122 Traffic  #");
        System.out.println("# s  ：查看表中的有效数据   > 案例：s T0                #");
        System.out.println("# S  ：查看表中的所有数据   > 案例：S T0                #");
        System.out.println("# c  ：清理屏幕             > 案例：c                   #");
        System.out.println("# H/h：查看帮助信息         > 案例：h                   #");
        System.out.println("# E/e：退出程序             > 案例：e                   #");
    }


    public static void initDicts() {
        dicts.put("noid", new Class_Dict(2, "对象编号的nextvalue"));
    }


    public static void writeDicts() {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(DICT_FILE))) {
            oos.writeObject(dicts);
            System.out.println("字典落盘成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public static void readDicts() {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(DICT_FILE))) {
            dicts = (Map<String, Class_Dict>) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("字典文件不存在，初始化中……");
            initDicts();
            writeDicts();
        }
    }


    public static void initTables() {
        Class_Table T0 = new Class_Table();
        T0.id = 0;
        T0.state = 2;
        T0.name = "T0";
        T0.oid = 0;
        T0.rows = 3;
        T0.cols = 2;
        T0.record.add(new ArrayList<>());
        T0.record.get(0).add("H");
        T0.record.get(0).add("TEL");
        T0.record.get(0).add("NAME");
        T0.record.add(new ArrayList<>());
        T0.record.get(1).add("A");
        T0.record.get(1).add("110");
        T0.record.get(1).add("police");
        T0.record.add(new ArrayList<>());
        T0.record.get(2).add("A");
        T0.record.get(2).add("120");
        T0.record.get(2).add("ambulance");
        T0.record.add(new ArrayList<>());
        T0.record.get(3).add("A");
        T0.record.get(3).add("119");
        T0.record.get(3).add("fire");
        tables.add(T0);

        Class_Table T1 = new Class_Table();
        T1.id = 1;
        T1.state = 2;
        T1.name = "T1";
        T1.oid = 1;
        T1.rows = 3;
        T1.cols = 2;
        T1.record.add(new ArrayList<>());
        T1.record.get(0).add("H");
        T1.record.get(0).add("country");
        T1.record.get(0).add("city");
        T1.record.add(new ArrayList<>());
        T1.record.get(1).add("A");
        T1.record.get(1).add("China");
        T1.record.get(1).add("Beijing");
        T1.record.add(new ArrayList<>());
        T1.record.get(2).add("A");
        T1.record.get(2).add("America");
        T1.record.get(2).add("Washington");
        T1.record.add(new ArrayList<>());
        T1.record.get(3).add("A");
        T1.record.get(3).add("Russia");
        T1.record.get(3).add("Moscow");
        tables.add(T1);
    }

    public static void writeTables() {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(DATA_FILE))) {
            oos.writeObject(tables);
            System.out.println("数据落盘成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @SuppressWarnings("unchecked")
    public static HashSet<Class_Table> readTables() {
        Set<Class_Table> loadedTables = new HashSet<>();
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(DATA_FILE))) {
            loadedTables = (Set<Class_Table>) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("数据文件不存在，初始化中……");
            initTables();
            writeTables();
            loadedTables = readTables();
            System.out.println("首次使用，将为您展示帮助信息：");
            printHelp();
        }
        return (HashSet<Class_Table>) loadedTables;
    }

} //Class_Main_end

//end

※ 如果您觉得文章写的还不错， 别忘了在文末给作者点个赞哦 ~

20200426194203245.gif​

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1577723.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

在线JSON工具

在线JSON工具

功能支持 ctrls json格式化游览器本地保存ctrla ctrlc 自动检测选中范围是否是全选&#xff0c;然后按照格式化方式添加到粘贴板中json 粘贴JSON自动格式化json可视化修改json压缩复制json层级折叠json关键key 搜索(自动提示高亮)满足某些近视的可以自行调整字体大小, 并且会游…
阅读更多...
React复习全攻略：重温旧知，收获新知

React复习全攻略：重温旧知，收获新知

简介 大背景&#xff1a; 起源于 Facebook 的内部项目&#xff0c;因为对市面上所有JS MVC框架不满意&#xff0c;就自己开发了一套&#xff0c;用来开发Instagram项目。&#xff08;开源时间&#xff1a;2013年5月&#xff09; 三句话解释&#xff1a; 是用于构建 Web 和原…
阅读更多...
MWeb Pro For Mac v4.5.9 强大的 Markdown 软件中文版

MWeb Pro For Mac v4.5.9 强大的 Markdown 软件中文版

MWeb 是专业的 Markdown 写作、记笔记、静态博客生成软件&#xff0c;目前已支持 Mac&#xff0c;iPad 和 iPhone。MWeb 有以下特色&#xff1a; 软件下载&#xff1a;MWeb Pro For Mac v4.5.9 软件本身&#xff1a; 使用原生的 macOS 技术打造&#xff0c;追求与系统的完美结合…
阅读更多...
OpenImageDebugger - CLion研究

OpenImageDebugger - CLion研究

在windows下有vistual studio&#xff0c;针对opencv有image watch&#xff0c;在ubuntu下用Clion插件Image Watch要收费&#xff0c;遂研究OpenImageDebugger与CLion问题&#xff0c;还有些未研究透彻&#xff0c;先记录当前部分。 Open Image Debugger Open Image Debugger …
阅读更多...
Linux文件IO(4):目录操作和文件属性获取

Linux文件IO(4):目录操作和文件属性获取

目录 1. 前言 2. 函数介绍 2.1 访问目录 – opendir 2.2 访问目录 – readdir 2.3 访问目录 – closedir 2.4 修改文件访问权限 – chmod/fchmod 2.5 获取文件属性 – stat/lstat/fstat 2.5.1 文件属性 – struct stat 2.6 文件类型 – st_mode 3. 代码练习 3.1 要求 3.2 代…
阅读更多...
深度挖掘商品信息，jd.item_get API助您呈现商品全面规格参数

深度挖掘商品信息，jd.item_get API助您呈现商品全面规格参数

深度挖掘商品信息&#xff0c;特别是在电商平台上&#xff0c;对于商家、开发者和用户来说都至关重要。jd.item_get API作为京东开放平台提供的一个强大工具&#xff0c;能够帮助用户轻松获取商品的全面规格参数&#xff0c;进而为商品分析、推荐、比较等提供有力的数据支撑。 …
阅读更多...
灵猫论文靠谱不 #职场发展#职场发展

灵猫论文靠谱不 #职场发展#职场发展

对于许多学生和研究人员来说&#xff0c;写论文是一个耗时且具有挑战性的任务。在撰写论文的过程中&#xff0c;除了要进行繁琐的写作工作外&#xff0c;还需要花费大量时间来查找资料、整理文献、检查语法和格式等。为了帮助大家轻松完成论文写作&#xff0c;现在有了许多写作…
阅读更多...
【QT入门】Qt自定义控件与样式设计之QPushButton常用qss

【QT入门】Qt自定义控件与样式设计之QPushButton常用qss

往期回顾 【QT入门】Qt自定义控件与样式设计之qss介绍(Qt style sheet)-CSDN博客 【QT入门】 Qt自定义控件与样式设计之qss选择器-CSDN博客 【QT入门】 Qt自定义控件与样式设计之QLineEdit的qss使用-CSDN博客 【QT入门】Qt自定义控件与样式设计之QPushButton常用qss 这里我们主…
阅读更多...
本地电脑渲染不行怎么解决?自助式渲染助你渲染无忧

本地电脑渲染不行怎么解决?自助式渲染助你渲染无忧

有时候&#xff0c;即使购买了昂贵的新电脑&#xff0c;我们也可能会遇到渲染速度缓慢、画质不佳或渲染失败等问题。这些问题可能由多种因素引起。针对该问题&#xff0c;为大家推荐了自助式的渲染&#xff0c;解决你本地电脑渲染不佳问题。 电脑渲染不行原因 新电脑渲染效果不…
阅读更多...
亚马逊AWS上怎么创建Linux 服务器？操作难不难？

亚马逊AWS上怎么创建Linux 服务器？操作难不难？

AWS(Amazon Web Services)是全球领先的云服务器提供商之一。你可以使用 AWS 平台在一分钟内设置完服务器。在 AWS 上&#xff0c;你可以微调服务器的许多技术细节&#xff0c;如 CPU 数量&#xff0c;内存和磁盘空间&#xff0c;磁盘类型(更快的 SSD 或者经典的 IDE)等。关于 A…
阅读更多...
【linux】set ff=unix、linux设置文件格式

【linux】set ff=unix、linux设置文件格式

文章目录 一、文件格式二、如何查看文件格式三、设置文件格式、set ffunix四、查看unix与dos的区别 一、文件格式 当我们打开sh脚本时发现有时候格式是unix(LF) ,有时候是windows(CR LF) 。如下图&#xff1a; 文件格式影响了文件中的换行符 linux中sh类型的文件一般要设置为…
阅读更多...
测试必备：网站崩溃原因大揭秘！12种常见问题一网打尽

测试必备：网站崩溃原因大揭秘！12种常见问题一网打尽

网站崩溃是研发团队最怕看到的情况&#xff0c;但是由于种种原因却时常出现&#xff0c;作为测试人员&#xff0c;我们更应该比一般人了解网站崩溃的原因及排查方法&#xff0c;这是我们测试工作的重要一环。接下来我就谈谈12种常见的网站崩溃原因以及如何跟踪和解决它们。 你的…
阅读更多...
纯小白蓝桥杯备赛笔记--DAY10（字符串）

纯小白蓝桥杯备赛笔记--DAY10（字符串）

文章目录 KMP字符串哈希算法简介&#xff1a;斤斤计较的小z--2047字符串hash Manacher回文串的性质算法简介最长回文子串 字典树基础朴素字符串查找步骤前缀判定--1204 01tire算法简介&#xff1a;例题1&#xff1a;例题2&#xff1a; KMP字符串哈希 算法简介&#xff1a; 真前…
阅读更多...
js将对象数组中的某个属性值，批量替换成另一个数值

js将对象数组中的某个属性值，批量替换成另一个数值

前提&#xff1a;对接口数据进行替换。把对应的数值或者字符串替换成中文。。。 核心代码&#xff1a; const toStr {sh: "沪",sz: "深", };myArr.map((item) > {const placeCode item.placeCode;item.placeCode toStr[placeCode] ? toStr[placeC…
阅读更多...
Xshell连接不上Ubuntu

Xshell连接不上Ubuntu

1 ubuntu安装ssh服务器 sudo apt install openssh-server修改配置文件vi /etc/ssh/sshd_config 修改如下两个配置 修改完运行下面代码。再用 xhell连接试试。 /etc/init.d/ssh restart
阅读更多...
普通相机标定——执行与结果验证

普通相机标定——执行与结果验证

在之前的准备工作中，我们完成了 棋盘格标靶的制作采集相机图像功能函数的实现相机内参标定功能函数实现工具类函数的实现 终于到了将他们组合起来实现相机内参标定的时刻了！这里作者用的是笔记本电脑的前置相机，首先调用SaveCameraImage()保存相机图像，同时手举棋盘…
阅读更多...
搜维尔科技：一个人如何使用Faceware为歌手制作完整的MV

搜维尔科技：一个人如何使用Faceware为歌手制作完整的MV

一个人如何使用Faceware为歌手制作完整的MV 最近&#xff0c;我们有机会采访了 Bryce&#xff0c;他是一位独立创作者&#xff0c;他通过使用 Faceware 来制作视频。完整采访如下&#xff1a; 这个项目是如何产生的&#xff1f;该项目的推动力是什么&#xff1f; “我爱你”M…
阅读更多...
字节出来的，太厉害了。。。。

字节出来的，太厉害了。。。。

&#x1f345; 视频学习&#xff1a;文末有免费的配套视频可观看 &#x1f345; 关注公众号【互联网杂货铺】&#xff0c;回复 1 &#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 前段时间公司缺人&#xff0c;也面了许多测试&#xff0c;一开始…
阅读更多...
【UE 网络】DS框架学习路线

【UE 网络】DS框架学习路线

目录 0 引言1 如何学习DS框架1. 熟悉Unreal Engine基础2. 学习网络编程基础3. 掌握UE网络概念4. 实践和实验5. 加入社区和论坛6. 官方示例和案例研究7. 专业书籍和在线课程 2 DS框架重要知识点有哪些1. 网络复制2. 远程过程调用&#xff08;RPC&#xff09;3. 客户端服务器架构…
阅读更多...
RabbitMQ基本使用及企业开发中注意事项

RabbitMQ基本使用及企业开发中注意事项

目录 一、基本使用 二、使用注意事项 1. 生产者重连机制 - 保证mq服务是通的 2. 生产者确认机制 - 回调机制 3. MQ的可靠性 4. Lazy Queue模式 5. 消费者确认机制 一、基本使用 部署完RabbitMQ有两种使用方式&#xff1a; 网页客户端Java代码 MQ组成部分&#xff1a;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023