devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：Monodyee | 2024-06-02 11:23:53

赞

踩

java数据库管理系统

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

★ 程序界面

★ 相关文章

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

★ 功能简介

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

★ 程序特点

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

★ 程序试用

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

★ 使用案例

  1. ############【欢迎使用 ZDB】############
  2. # 语言：Java 17          IDE：IntelliJ #
  3. # 作者：zzt_2009         版本：V 7.0.0 #
  4. # 主页：https://blog.csdn.net/zzt_2009 #
  5. # [H/h]查看帮助          [E/e]退出程序 #
  6. 字典文件不存在，初始化中……
  7. 字典落盘成功
  8. 数据文件不存在，初始化中……
  9. 数据落盘成功
  10. 首次使用，将为您展示帮助信息：
  11. # L  ：列出所有表的信息     > 案例：L T0                #
  12. # C  ：创建表并指定列名     > 案例：C T0 ID NAME        #
  13. # D  ：删除表（支持闪回） 	> 案例：D T0                #
  14. # A  ：修改表的所有列名     > 案例：A T0 IDS NAMES      #
  15. # R  ：重命名表的名称       > 案例：R T0 T00            #
  16. # T  ：清空表中的数据       > 案例：T T0                #
  17. # F  ：闪回被删除的表       > 案例：F T0_$0             #
  18. # P  ：清空被删除的表       > 案例：P                   #
  19. # i  ：往表中插入1行数据    > 案例：i T0 122 Traffic    #
  20. # d  ：从表中删除1行数据    > 案例：d T0 3              #
  21. # u  ：更新表中的1行数据    > 案例：u T0 3 122 Traffic  #
  22. # s  ：查看表中的有效数据   > 案例：s T0                #
  23. # S  ：查看表中的所有数据   > 案例：S T0                #
  24. # c  ：清理屏幕             > 案例：c                   #
  25. # H/h：查看帮助信息         > 案例：h                   #
  26. # E/e：退出程序             > 案例：e                   #
  27. SQL > L
  28. 表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
  29. 表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
  30. 对象的nextvalue：2
  31. 状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
  32. SQL > C T2 ID NAME
  33. 表 T2 创建成功。
  34. 字典落盘成功
  35. 数据落盘成功
  36. 表名: T2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
  37. 表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
  38. 表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
  39. 对象的nextvalue：3
  40. 状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
  41. SQL > C T3 ID NAME COMMENT
  42. 表 T3 创建成功。
  43. 字典落盘成功
  44. 数据落盘成功
  45. 表名: T2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
  46. 表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
  47. 表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
  48. 表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
  49. 对象的nextvalue：4
  50. 状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
  51. SQL > D T2
  52. 表 T2 删除成功。
  53. 字典落盘成功
  54. 数据落盘成功
  55. 表名: T2_$2	编号: 2	状态: 3	Rows: 0	Cols: 2 [ ID/NAME/ ]
  56. 表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
  57. 表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
  58. 表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
  59. 对象的nextvalue：4
  60. 状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
  61. SQL > F T2_$2
  62. 表 T2_$2 已被恢复。
  63. 字典落盘成功
  64. 数据落盘成功
  65. 表名: T2_$2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
  66. 表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
  67. 表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
  68. 表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
  69. 对象的nextvalue：4
  70. 状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
  71. SQL > R T2_$2 T2
  72. 表 T2_$2 更名为 T2 成功。
  73. 字典落盘成功
  74. 数据落盘成功
  75. 表名: T2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
  76. 表名: T0	编号: 0	状态: 2	Rows: 3	Cols: 2 [ TEL/NAME/ ]
  77. 表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
  78. 表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
  79. 对象的nextvalue：4
  80. 状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
  81. SQL > s T0
  82. 行号：0	数据：[H, TEL, NAME]
  83. 行号：1	数据：[A, 110, police]
  84. 行号：2	数据：[A, 120, ambulance]
  85. 行号：3	数据：[A, 119, fire]
  86. SQL > d T0 2
  87. 相关行数据已删除。
  88. 字典落盘成功
  89. 数据落盘成功
  90. 行号：0	数据：[H, TEL, NAME]
  91. 行号：1	数据：[A, 110, police]
  92. 行号：2	数据：[A, 119, fire]
  93. SQL > S T0
  94. 行号：0	数据：[H, TEL, NAME]
  95. 行号：1	数据：[A, 110, police]
  96. 行号：2	数据：[D, 120, ambulance]
  97. 行号：3	数据：[A, 119, fire]
  98. SQL > i T0 122 car
  99. 0 / H
  100. 1 / A
  101. 2 / D
  102. 数据插入表 T0 成功。
  103. 字典落盘成功
  104. 数据落盘成功
  105. 行号：0	数据：[H, TEL, NAME]
  106. 行号：1	数据：[A, 110, police]
  107. 行号：2	数据：[A, 122, car]
  108. 行号：3	数据：[A, 119, fire]
  109. SQL > u T0 2 120 doctor
  110. 数据更新成功。
  111. 字典落盘成功
  112. 数据落盘成功
  113. 行号：0	数据：[H, TEL, NAME]
  114. 行号：1	数据：[A, 110, police]
  115. 行号：2	数据：[A, 120, doctor]
  116. 行号：3	数据：[A, 119, fire]
  117. SQL > T T0
  118. 表 T0 已被截断。
  119. 字典落盘成功
  120. 数据落盘成功
  121. 表名: T2	编号: 2	状态: 1	Rows: 0	Cols: 2 [ ID/NAME/ ]
  122. 表名: T0	编号: 0	状态: 2	Rows: 0	Cols: 2 [ TEL/NAME/ ]
  123. 表名: T3	编号: 3	状态: 1	Rows: 0	Cols: 3 [ ID/NAME/COMMENT/ ]
  124. 表名: T1	编号: 1	状态: 2	Rows: 3	Cols: 2 [ country/city/ ]
  125. 对象的nextvalue：4
  126. 状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
  127. SQL > S T0
  128. 行号：0	数据：[H, TEL, NAME]
  129. SQL > e
  130. 字典落盘成功
  131. 数据落盘成功
  132. #########【感谢使用 ZDB 再见!】#########

★ 程序源码

  1. package zdb_default;
  2.  
  3. import java.io.*;
  4. import java.util.*;
  5.  
  6. // 字典类（程序较为简单为了减少文件切换使用内部类方式）
  7. class Class_Dict implements Serializable { // 实现 Serializable 接口，这是进行对象序列化和反序列化所必需的。
  8.     private static final long serialVersionUID = 1L; // 为了在版本升级时保持版本的兼容性，在序列化类中添加 serialVersionUID
  9.     public int value;       //值
  10.     public String comment;  //描述
  11.  
  12.     // 添加构造函数和getter/setter方法（如果需要）
  13.     public Class_Dict(int value, String comment) {
  14.         this.value = value;
  15.         this.comment = comment;
  16.     }
  17.  
  18.     // 如果需要，还可以添加toString方法
  19.     @Override
  20.     public String toString() {
  21.         return "Class_Dict{" +
  22.                 "value=" + value +
  23.                 ", comment='" + comment + '\'' +
  24.                 '}';
  25.     }
  26. }
  27.  
  28. // 表类（程序较为简单为了减少文件切换使用内部类方式）
  29. class Class_Table implements Serializable { // 实现 Serializable 接口，这是进行对象序列化和反序列化所必需的。
  30.     private static final long serialVersionUID = 1L; // 为了在版本升级时保持版本的兼容性，在序列化类中添加 serialVersionUID
  31.     public int id;            // 序号
  32.     public int state;         // 状态：0>未分配、1>新表、2>有数、3>删除、4>可复用
  33.     public String name;       // 名称
  34.     public int oid;           // 对象编号
  35.     public int rows;          // 行数
  36.     public int cols;          // 列数
  37.     public List<List<String>> record = new ArrayList<>(); // 数据&状态："">未分配、H>字段名、A>可用、D>删除
  38. }
  39.  
  40. public class Class_Main {
  41.     // 定义常量
  42.     private static final String DICT_FILE = "ZDB.dic";
  43.     private static final String DATA_FILE = "ZDB.dat";
  44.     // 创建一个Set集合来存储Class_Dict对象（参数）
  45.     private static Map<String, Class_Dict> dicts = new HashMap<>();
  46.     // 创建一个Set集合来存储Class_Table对象（表）
  47.     private static Set<Class_Table> tables = new HashSet<>();
  48.  
  49.     public static void main(String[] args) {
  50.         // 显示头信息
  51.         printHead();
  52.         // 从文件中读取字典信息到集合中
  53.         readDicts();
  54.         // 从文件中读取表信息到集合中
  55.         tables = readTables();
  56.         // 读取输入
  57.         while (true) {
  58.             String table_name;
  59.             System.out.print("SQL > ");
  60.             Scanner scanner = new Scanner(System.in);
  61.             String command = scanner.nextLine();
  62.             String[] tokens = command.split(" ");
  63.             String operation = tokens[0];
  64.             switch (operation) {
  65.                 case "C": // 创建新表，用法：C T0 id name
  66.                     createTable(tokens);
  67.                     break;
  68.                 case "D": // 删除表，用法：D T0
  69.                     dropTable(tokens);
  70.                     break;
  71.                 case "A": // 修改表列名，用法：A T0 new_id new_name
  72.                     alterTable(tokens);
  73.                     break;
  74.                 case "R": // 重命名表，用法：R T0 T00
  75.                     renameTable(tokens);
  76.                     break;
  77.                 case "T": // 清空表数据，用法：T T0
  78.                     truncateTable(tokens);
  79.                     break;
  80.                 case "F": // 闪回删除的表，用法：F T0
  81.                     flashbackTable(tokens);
  82.                     break;
  83.                 case "P": // 清空所有已删除的表，用法：P
  84.                     purgeTables();
  85.                     break;
  86.                 case "L": // 列出库中所有表名和其基础信息，用法：L
  87.                     listTables();
  88.                     break;
  89.                 case "i": // 往表插入数据，用法：i T0 1 a 2 b 3 c
  90.                     insertTable(tokens);
  91.                     break;
  92.                 case "d": // 删除表中第N行数据，用法：d T0 N
  93.                     deleteTable(tokens);
  94.                     break;
  95.                 case "u": // 更新表中第N行数据，用法：u T0 N 1 a
  96.                     updateTable(tokens);
  97.                     break;
  98.                 case "s": // 查询表中所有可见数据，用法：s T0
  99.                     selectTable(tokens);
  100.                     break;
  101.                 case "S": // 查询表中所有数据，用法：S T0
  102.                     selectAllTable(tokens);
  103.                     break;
  104.                 case "c": // 清理屏幕并重新显示printHead()
  105.                     printHead();
  106.                     break;
  107.                 case "h": //
  108.                 case "H": //
  109.                     printHelp();
  110.                     break;
  111.                 case "e": //
  112.                 case "E": //
  113.                     writeDicts();
  114.                     writeTables();
  115.                     printEnd();
  116.                     System.exit(0);
  117.                 default:
  118.                     System.out.println("命令不正确请重新输入，或按[H/h]查看帮助");
  119.                     break;
  120.             }
  121.         } //循环结束
  122.     } //main_end
  123.  
  124.  
  125.     public static void createTable(String[] tokens) {
  126.         if (tokens.length < 3) {
  127.             System.out.println("输入有误，案例：C T0 ID NAME");
  128.             return;
  129.         }
  130.         String tableName = tokens[1];
  131.         for (Class_Table table : tables) {
  132.             if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
  133.                 System.out.println("表 " + tableName + " 已存在。");
  134.                 return;
  135.             }
  136.         }
  137.         Class_Table newTable = new Class_Table();
  138.         newTable.state = 1;
  139.         newTable.name = tableName;
  140.         newTable.oid = dicts.get("noid").value;
  141.         newTable.rows = 0;
  142.         newTable.cols = (tokens.length - 2);
  143.         dicts.put("noid", new Class_Dict((dicts.get("noid").value + 1), "对象编号的nextvalue"));
  144.         List<String> header = new ArrayList<>();
  145.         header.add("H");
  146.         header.addAll(Arrays.asList(tokens).subList(2, tokens.length));
  147.         newTable.record.add(header);
  148.         tables.add(newTable);
  149.         System.out.println("表 " + tableName + " 创建成功。");
  150.         writeDicts();
  151.         writeTables();
  152.         listTables();
  153.     }
  154.  
  155.     public static void dropTable(String[] tokens) {
  156.         if (tokens.length != 2) {
  157.             System.out.println("输入有误，案例：D T0");
  158.             return;
  159.         }
  160.         String tableName = tokens[1];
  161.         boolean found = false;
  162.         for (Class_Table table : tables) {
  163.             if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
  164.                 table.state = 3;
  165.                 table.name = table.name + "_$" + table.oid;
  166.                 found = true;
  167.                 break;
  168.             }
  169.         }
  170.         if (found) {
  171.             System.out.println("表 " + tableName + " 删除成功。");
  172.             writeDicts();
  173.             writeTables();
  174.             listTables();
  175.         } else {
  176.             System.out.println("表 " + tableName + " 不存在或已被删除。");
  177.         }
  178.     }
  179.  
  180.     public static void renameTable(String[] tokens) {
  181.         if (tokens.length != 3) {
  182.             System.out.println("命令错误，请检查参数数量。");
  183.             return;
  184.         }
  185.         String oldName = tokens[1];
  186.         String newName = tokens[2];
  187.         for (Class_Table table : tables) {
  188.             if ((table.name.equals(oldName)) && ((table.state == 1) || (table.state == 2))) {
  189.                 table.name = newName;
  190.                 System.out.println("表 " + oldName + " 更名为 " + newName + " 成功。");
  191.                 writeDicts();
  192.                 writeTables();
  193.                 listTables();
  194.                 return;
  195.             }
  196.         }
  197.         System.out.println("表 " + oldName + " 不存在。");
  198.     }
  199.  
  200.     public static void alterTable(String[] tokens) {
  201.         if (tokens.length < 3) {
  202.             System.out.println("输入有误，案例：A T0 new_col1 new_col2");
  203.             return;
  204.         }
  205.         String tableName = tokens[1];
  206.         for (Class_Table table : tables) {
  207.             if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
  208.                 if ((tokens.length - 2) == table.cols) {
  209.                     List<String> header = new ArrayList<>();
  210.                     header.add("H");
  211.                     header.addAll(Arrays.asList(tokens).subList(2, tokens.length));
  212.                     table.record.set(0, header);
  213.                     writeDicts();
  214.                     writeTables();
  215.                     listTables();
  216.                 } else {
  217.                     System.out.println("新列数量须和旧列数量一致！");
  218.                 }
  219.                 return;
  220.             }
  221.         }
  222.         System.out.println("表 " + tableName + " 不存在。");
  223.     }
  224.  
  225.  
  226.     public static void truncateTable(String[] tokens) {
  227.         if (tokens.length != 2) {
  228.             System.out.println("输入有误，案例：T T0");
  229.             return;
  230.         }
  231.         String tableName = tokens[1];
  232.         boolean tableFound = false;
  233.         for (Class_Table table : tables) {
  234.             if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
  235.                 tableFound = true;
  236.                 List<String> header = table.record.get(0);
  237.                 table.record.clear();
  238.                 table.rows = 0;
  239.                 table.record.add(header);
  240.                 System.out.println("表 " + tableName + " 已被截断。");
  241.                 writeDicts();
  242.                 writeTables();
  243.                 listTables();
  244.                 break;
  245.             }
  246.         }
  247.         if (!tableFound) {
  248.             System.out.println("表 " + tableName + " 不存在。");
  249.         }
  250.     }
  251.  
  252.     public static void flashbackTable(String[] tokens) {
  253.         if (tokens.length != 2) {
  254.             System.out.println("输入有误，案例：F T0");
  255.             return;
  256.         }
  257.         String tableName = tokens[1];
  258.         boolean tableFound = false;
  259.         for (Class_Table table : tables) {
  260.             if (table.name.equals(tableName) && table.state == 3) {
  261.                 tableFound = true;
  262.                 if (table.rows == 0) {
  263.                     table.state = 1;
  264.                 } else {
  265.                     table.state = 2;
  266.                 }
  267.                 System.out.println("表 " + tableName + " 已被恢复。");
  268.                 writeDicts();
  269.                 writeTables();
  270.                 listTables();
  271.                 break;
  272.             }
  273.         }
  274.         if (!tableFound) {
  275.             System.out.println("表 " + tableName + " 不存在或未被删除。");
  276.         }
  277.     }
  278.  
  279.     public static void purgeTables() {
  280.         tables.removeIf(table -> table.state == 3);
  281.         System.out.println("所有标记为删除的表已清除。");
  282.     }
  283.  
  284.     public static void listTables() {
  285.         tables.forEach(table -> {
  286.             System.out.print("表名: " + table.name + "\t");
  287.             System.out.print("编号: " + table.oid + "\t");
  288.             System.out.print("状态: " + table.state + "\t");
  289.             System.out.print("Rows: " + table.rows + "\t");
  290.             System.out.print("Cols: " + table.cols + " ");
  291.             System.out.print("[ ");
  292.             for (int i = 1; i < table.record.get(0).size(); i++) {
  293.                 System.out.print(table.record.get(0).get(i) + "/");
  294.             }
  295.             System.out.println(" ]");
  296.         });
  297.         System.out.println("对象的nextvalue：" + dicts.get("noid").value);
  298.         System.out.println("状态：0>未分配、1>新表、2>有数、3>删除、4>可复用");
  299.     }
  300.  
  301.     public static void insertTable(String[] tokens) {
  302.         if (tokens.length < 3) {
  303.             System.out.println("输入有误，案例：i T0 911 fire");
  304.             return;
  305.         }
  306.         String tableName = tokens[1];
  307.         for (Class_Table table : tables) {
  308.             if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
  309.                 if ((tokens.length - 2) == table.cols) {
  310.                     for (int i = 0; i < table.record.size(); i++) {
  311.                         System.out.println(i + " / " + table.record.get(i).get(0));
  312.                         if (Objects.equals(table.record.get(i).get(0), "D")) {
  313.                             List<String> rowData = new ArrayList<>();
  314.                             rowData.add(0, "A");
  315.                             rowData.addAll(Arrays.asList(tokens).subList(2, tokens.length));
  316.                             table.record.set(i, rowData);
  317.                             table.rows++;
  318.                             System.out.println("数据插入表 " + tableName + " 成功。");
  319.                             writeDicts();
  320.                             writeTables();
  321.                             selectTable(("X " + tableName).split(" "));
  322.                             return;
  323.                         }
  324.                     }
  325.                     List<String> rowData = new ArrayList<>();
  326.                     rowData.add(0, "A");
  327.                     rowData.addAll(Arrays.asList(tokens).subList(2, tokens.length));
  328.                     table.record.add(rowData);
  329.                     table.rows++;
  330.                     System.out.println("数据插入表 " + tableName + " 成功。");
  331.                     writeDicts();
  332.                     writeTables();
  333.                     selectTable(("X " + tableName).split(" "));
  334.                 } else {
  335.                     System.out.println("列数量不一致！");
  336.                 }
  337.                 return;
  338.             }
  339.         }
  340.         System.out.println("表 " + tableName + " 不存在。");
  341.     }
  342.  
  343.     public static void deleteTable(String[] tokens) {
  344.         if (tokens.length != 3) {
  345.             System.out.println("输入有误，案例：d T0 1");
  346.             return;
  347.         }
  348.         String tableName = tokens[1];
  349.         String rowNumber = tokens[2];
  350.         int irowNumber = Integer.parseInt(rowNumber);
  351.         boolean tableFound = false;
  352.         for (Class_Table table : tables) {
  353.             if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
  354.                 if ((irowNumber != 0) && (irowNumber <= table.rows)) {
  355.                     tableFound = true;
  356.                     table.record.get(irowNumber).set(0, "D");
  357.                     table.rows--;
  358.                     System.out.println("相关行数据已删除。");
  359.                     writeDicts();
  360.                     writeTables();
  361.                     selectTable(("X " + tableName).split(" "));
  362.                     return;
  363.                 } else {
  364.                     System.out.println("不可操作的行号。");
  365.                     return;
  366.                 }
  367.             }
  368.         }
  369.         if (!tableFound) {
  370.             System.out.println("表 " + tableName + " 不存在。");
  371.         }
  372.     }
  373.  
  374.     public static void updateTable(String[] tokens) {
  375.  
  376.         if (tokens.length < 4) {
  377.             System.out.println("输入有误，案例：u T0 1 110 police");
  378.             return;
  379.         }
  380.         String tableName = tokens[1];
  381.         String rowNumber = tokens[2];
  382.         int irowNumber = Integer.parseInt(rowNumber);
  383.         boolean tableFound = false;
  384.         for (Class_Table table : tables) {
  385.             if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
  386.                 tableFound = true;
  387.                 if (table.record.get(irowNumber).get(0).equals("A")) {
  388.                     if ((tokens.length - 3) == table.cols) {
  389.                         List<String> rowData = new ArrayList<>();
  390.                         rowData.add(0, "A");
  391.                         rowData.addAll(Arrays.asList(tokens).subList(3, tokens.length));
  392.                         table.record.set(irowNumber, rowData);
  393.                         System.out.println("数据更新成功。");
  394.                         writeDicts();
  395.                         writeTables();
  396.                         selectTable(("X " + tableName).split(" "));
  397.                     } else {
  398.                         System.out.println("列数量不一致！");
  399.                     }
  400.                     return;
  401.                 }
  402.             }
  403.         }
  404.         if (!tableFound) {
  405.             System.out.println("表 " + tableName + " 不存在。");
  406.         }
  407.     }
  408.  
  409.     public static void selectTable(String[] tokens) {
  410.         if (tokens.length != 2) {
  411.             System.out.println("输入有误，案例：s T0");
  412.             return;
  413.         }
  414.         String tableName = tokens[1];
  415.         boolean tableFound = false;
  416.         for (Class_Table table : tables) {
  417.             if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
  418.                 tableFound = true;
  419.                 int i = 0;
  420.                 for (List<String> row : table.record) {
  421.                     if ((row.get(0).equals("H")) || (row.get(0).equals("A"))) {
  422.                         System.out.println("行号：" + i + "\t数据：" + row);
  423.                         i++;
  424.                     }
  425.                 }
  426.                 break;
  427.             }
  428.         }
  429.         if (!tableFound) {
  430.             System.out.println("表 " + tableName + " 不存在。");
  431.         }
  432.     }
  433.  
  434.  
  435.     public static void selectAllTable(String[] tokens) {
  436.         if (tokens.length != 2) {
  437.             System.out.println("输入有误，案例：s T0");
  438.             return;
  439.         }
  440.         String tableName = tokens[1];
  441.         boolean tableFound = false;
  442.         for (Class_Table table : tables) {
  443.             if ((table.name.equals(tableName)) && ((table.state == 1) || (table.state == 2))) {
  444.                 tableFound = true;
  445.                 int i = 0;
  446.                 for (List<String> row : table.record) {
  447.                     System.out.println("行号：" + i + "\t数据：" + row);
  448.                     i++;
  449.                 }
  450.                 break;
  451.             }
  452.         }
  453.         if (!tableFound) {
  454.             System.out.println("表 " + tableName + " 不存在。");
  455.         }
  456.     }
  457.  
  458.     public static void printHead() {
  459.         try {
  460.             new ProcessBuilder("cmd", "/c", "cls").inheritIO().start().waitFor();
  461.         } catch (IOException | InterruptedException e) {
  462.             e.printStackTrace();
  463.         }
  464.         System.out.println("############【欢迎使用 ZDB】############");
  465.         System.out.println("# 语言：Java 17          IDE：IntelliJ #");
  466.         System.out.println("# 作者：zzt_2009         版本：V 7.0.0 #");
  467.         System.out.println("# 主页：https://blog.csdn.net/zzt_2009 #");
  468.         System.out.println("# [H/h]查看帮助          [E/e]退出程序 #");
  469.     }
  470.  
  471.     public static void printEnd() {
  472.         System.out.println("#########【感谢使用 ZDB 再见!】#########");
  473.     }
  474.  
  475.     public static void printHelp() {
  476.         System.out.println("# L  ：列出所有表的信息     > 案例：L T0                #");
  477.         System.out.println("# C  ：创建表并指定列名     > 案例：C T0 ID NAME        #");
  478.         System.out.println("# D  ：删除表（支持闪回）   > 案例：D T0                #");
  479.         System.out.println("# A  ：修改表的所有列名     > 案例：A T0 IDS NAMES      #");
  480.         System.out.println("# R  ：重命名表的名称       > 案例：R T0 T00            #");
  481.         System.out.println("# T  ：清空表中的数据       > 案例：T T0                #");
  482.         System.out.println("# F  ：闪回被删除的表       > 案例：F T0_$0             #");
  483.         System.out.println("# P  ：清空被删除的表       > 案例：P                   #");
  484.         System.out.println("# i  ：往表中插入1行数据    > 案例：i T0 122 Traffic    #");
  485.         System.out.println("# d  ：从表中删除1行数据    > 案例：d T0 3              #");
  486.         System.out.println("# u  ：更新表中的1行数据    > 案例：u T0 3 122 Traffic  #");
  487.         System.out.println("# s  ：查看表中的有效数据   > 案例：s T0                #");
  488.         System.out.println("# S  ：查看表中的所有数据   > 案例：S T0                #");
  489.         System.out.println("# c  ：清理屏幕             > 案例：c                   #");
  490.         System.out.println("# H/h：查看帮助信息         > 案例：h                   #");
  491.         System.out.println("# E/e：退出程序             > 案例：e                   #");
  492.     }
  493.  
  494.  
  495.     public static void initDicts() {
  496.         dicts.put("noid", new Class_Dict(2, "对象编号的nextvalue"));
  497.     }
  498.  
  499.  
  500.     public static void writeDicts() {
  501.         try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(DICT_FILE))) {
  502.             oos.writeObject(dicts);
  503.             System.out.println("字典落盘成功");
  504.         } catch (IOException e) {
  505.             e.printStackTrace();
  506.         }
  507.     }
  508.  
  509.  
  510.     public static void readDicts() {
  511.         try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(DICT_FILE))) {
  512.             dicts = (Map<String, Class_Dict>) ois.readObject();
  513.         } catch (IOException | ClassNotFoundException e) {
  514.             System.out.println("字典文件不存在，初始化中……");
  515.             initDicts();
  516.             writeDicts();
  517.         }
  518.     }
  519.  
  520.  
  521.     public static void initTables() {
  522.         Class_Table T0 = new Class_Table();
  523.         T0.id = 0;
  524.         T0.state = 2;
  525.         T0.name = "T0";
  526.         T0.oid = 0;
  527.         T0.rows = 3;
  528.         T0.cols = 2;
  529.         T0.record.add(new ArrayList<>());
  530.         T0.record.get(0).add("H");
  531.         T0.record.get(0).add("TEL");
  532.         T0.record.get(0).add("NAME");
  533.         T0.record.add(new ArrayList<>());
  534.         T0.record.get(1).add("A");
  535.         T0.record.get(1).add("110");
  536.         T0.record.get(1).add("police");
  537.         T0.record.add(new ArrayList<>());
  538.         T0.record.get(2).add("A");
  539.         T0.record.get(2).add("120");
  540.         T0.record.get(2).add("ambulance");
  541.         T0.record.add(new ArrayList<>());
  542.         T0.record.get(3).add("A");
  543.         T0.record.get(3).add("119");
  544.         T0.record.get(3).add("fire");
  545.         tables.add(T0);
  546.  
  547.         Class_Table T1 = new Class_Table();
  548.         T1.id = 1;
  549.         T1.state = 2;
  550.         T1.name = "T1";
  551.         T1.oid = 1;
  552.         T1.rows = 3;
  553.         T1.cols = 2;
  554.         T1.record.add(new ArrayList<>());
  555.         T1.record.get(0).add("H");
  556.         T1.record.get(0).add("country");
  557.         T1.record.get(0).add("city");
  558.         T1.record.add(new ArrayList<>());
  559.         T1.record.get(1).add("A");
  560.         T1.record.get(1).add("China");
  561.         T1.record.get(1).add("Beijing");
  562.         T1.record.add(new ArrayList<>());
  563.         T1.record.get(2).add("A");
  564.         T1.record.get(2).add("America");
  565.         T1.record.get(2).add("Washington");
  566.         T1.record.add(new ArrayList<>());
  567.         T1.record.get(3).add("A");
  568.         T1.record.get(3).add("Russia");
  569.         T1.record.get(3).add("Moscow");
  570.         tables.add(T1);
  571.     }
  572.  
  573.     public static void writeTables() {
  574.         try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(DATA_FILE))) {
  575.             oos.writeObject(tables);
  576.             System.out.println("数据落盘成功");
  577.         } catch (IOException e) {
  578.             e.printStackTrace();
  579.         }
  580.     }
  581.  
  582.     @SuppressWarnings("unchecked")
  583.     public static HashSet<Class_Table> readTables() {
  584.         Set<Class_Table> loadedTables = new HashSet<>();
  585.         try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(DATA_FILE))) {
  586.             loadedTables = (Set<Class_Table>) ois.readObject();
  587.         } catch (IOException | ClassNotFoundException e) {
  588.             System.out.println("数据文件不存在，初始化中……");
  589.             initTables();
  590.             writeTables();
  591.             loadedTables = readTables();
  592.             System.out.println("首次使用，将为您展示帮助信息：");
  593.             printHelp();
  594.         }
  595.         return (HashSet<Class_Table>) loadedTables;
  596.     }
  597.  
  598. } //Class_Main_end
  599.  
  600. //end

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

20200426194203245.gif​

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/662515
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号