将Java控制台输入添加到ArrayList并持久化

本文介绍了如何将Java控制台输入添加到ArrayList，并解决每次程序运行时ArrayList内容被重置的问题。通过使用`java.io.ObjectInputStream`和`java.io.ObjectOutputStream`将ArrayList对象本地存储，实现了数据的持久化，使得程序能够从文件中加载之前的输入，从而避免数据丢失。

在Java程序中，如果希望在每次程序运行时都保留用户输入的数据，而不是每次都从零开始，就需要将数据进行持久化存储。一种简单有效的方法是使用Java的序列化机制将ArrayList保存到本地文件，并在程序启动时从文件中加载数据。

序列化与反序列化

Java的序列化允许将对象转换为字节流，以便存储到文件或通过网络传输。反序列化则是将字节流转换回对象的过程。java.io.ObjectOutputStream用于将对象写入输出流，而java.io.ObjectInputStream用于从输入流读取对象。

立即学习“Java免费学习笔记（深入）”；

实现步骤

1. 保存ArrayList到文件：

   以下代码展示了如何将ArrayList保存到文件中。

   import java.io.*;
   import java.util.ArrayList;
   
   public class ArrayListPersistence {
   
       public static void saveArrayList(ArrayList<Object> arr, String filename) {
           ObjectOutputStream oos = null;
           try {
               oos = new ObjectOutputStream(new FileOutputStream(filename));
               oos.writeObject(arr);
           } catch (IOException e) {
               e.printStackTrace();
           } finally {
               if (oos != null) {
                   try {
                       oos.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   }

   这段代码创建了一个名为saveArrayList的静态方法，它接收一个ArrayList和一个文件名作为参数。它使用ObjectOutputStream将ArrayList写入指定的文件。请注意，ArrayList中存储的对象必须是可序列化的（即实现java.io.Serializable接口）。

2. 从文件加载ArrayList：

   

   Tome

   先进的AI智能PPT制作工具

   下载

   以下代码展示了如何从文件中加载ArrayList。

   import java.io.*;
   import java.util.ArrayList;
   
   public class ArrayListPersistence {
   
       public static ArrayList<Object> loadArrayList(String filename) {
           ObjectInputStream ois = null;
           try {
               ois = new ObjectInputStream(new FileInputStream(filename));
               ArrayList<Object> arr = (ArrayList<Object>) ois.readObject();
               return arr;
           } catch (IOException e) {
               e.printStackTrace();
               return new ArrayList<>(); // 返回一个空ArrayList，避免空指针异常
           } catch (ClassNotFoundException e) {
               e.printStackTrace();
               return new ArrayList<>(); // 返回一个空ArrayList，避免空指针异常
           } finally {
               if (ois != null) {
                   try {
                       ois.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   }

   这段代码创建了一个名为loadArrayList的静态方法，它接收一个文件名作为参数。它使用ObjectInputStream从指定的文件读取ArrayList。如果文件不存在或发生其他IO异常，该方法会返回一个新的空ArrayList，避免程序崩溃。ClassNotFoundException也需要处理，它会在找不到ArrayList中存储的对象的类定义时抛出。

3. 修改User类：

   为了使用上述方法，需要修改User类，使其实现Serializable接口，并且在程序启动时加载数据，在程序退出时保存数据。

   import java.io.*;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Scanner;
   
   public class User implements Serializable {
   
       private static final long serialVersionUID = 1L; // 建议添加serialVersionUID
       private static List<String> listNames = new ArrayList<>();
       private static List<Integer> listIds = new ArrayList<>();
       private int ID;
       private String name;
       private static final String DATA_FILE = "user_data.ser"; // 数据文件名
   
       public static void main(String[] args) {
           // 加载数据
           List<?> loadedNames = (List<?>) loadArrayList(DATA_FILE + "_names");
           List<?> loadedIds = (List<?>) loadArrayList(DATA_FILE + "_ids");
   
           if (loadedNames != null) {
               listNames = (List<String>) loadedNames;
           }
           if (loadedIds != null) {
               listIds = (List<Integer>) loadedIds;
           }
   
           int tempID = 5000;
           if (args.length > 0) {
               tempID = Integer.parseInt(args[0]);
           }
           System.out.println("Login  " + tempID);
   
           Scanner scanner = new Scanner(System.in);
           System.out.print("Enter your Name : ");
           String tempName = scanner.nextLine();
   
           User n = new User();
           n.ID = tempID;
           n.name = tempName;
           listIds.add(n.ID);
           listNames.add(n.name);
   
           // 保存数据
           saveArrayList((ArrayList<Object>) listNames, DATA_FILE + "_names");
           saveArrayList((ArrayList<Object>) listIds, DATA_FILE + "_ids");
   
       }
   
       public static ArrayList<Object> loadArrayList(String filename) {
           ObjectInputStream ois = null;
           try {
               ois = new ObjectInputStream(new FileInputStream(filename));
               ArrayList<Object> arr = (ArrayList<Object>) ois.readObject();
               return arr;
           } catch (IOException e) {
               System.out.println("Error loading data from " + filename + ": " + e.getMessage());
               return new ArrayList<>();
           } catch (ClassNotFoundException e) {
               System.out.println("Class not found while loading data: " + e.getMessage());
               return new ArrayList<>();
           } finally {
               if (ois != null) {
                   try {
                       ois.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   
       public static void saveArrayList(ArrayList<Object> arr, String filename) {
           ObjectOutputStream oos = null;
           try {
               oos = new ObjectOutputStream(new FileOutputStream(filename));
               oos.writeObject(arr);
           } catch (IOException e) {
               e.printStackTrace();
           } finally {
               if (oos != null) {
                   try {
                       oos.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   }

   在这个修改后的版本中，User类实现了Serializable接口，并且添加了一个serialVersionUID。serialVersionUID用于在序列化和反序列化过程中验证类的版本兼容性。在main方法中，首先尝试从文件中加载数据，如果文件不存在，则使用空的ArrayList。在程序结束前，将ArrayList保存到文件中。

注意事项

• Serializable接口： 要序列化的类及其所有非瞬态（non-transient）字段都必须实现Serializable接口。
• serialVersionUID： 建议为可序列化的类显式定义serialVersionUID。如果未显式定义，编译器会自动生成一个，但如果类的结构发生变化，可能会导致反序列化失败。
• 异常处理： 在进行文件读写操作时，务必进行适当的异常处理，以避免程序崩溃。
• 安全性： 序列化机制存在安全风险，特别是反序列化来自不可信来源的数据。需要谨慎处理，避免潜在的安全漏洞。
• 数据类型: 注意类型转换的安全性，在loadArrayList返回后，需要将Object类型转换为对应的List或者List，需要进行类型检查，防止ClassCastException。

总结

通过使用Java的序列化机制，可以方便地将ArrayList保存到本地文件，并在程序启动时加载数据，从而实现数据的持久化。这种方法简单易用，适用于小型应用程序或原型开发。对于大型应用程序，可能需要考虑使用数据库或其他更高级的持久化方案。