1. import java.util.*;
  2. import java.io.*;
  4. public class CollectionRestorer {
  6. /**
  7. * Restores data of collections from a file.
  8. * Handles potential file reading errors and data parsing issues gracefully.
  9. * @param filename The name of the file containing the collection data.
  10. * @param <T> The type of elements in the collections.
  11. * @return A map containing the restored collections, or null if an error occurred.
  12. */
  13. public <T> Map<String, List<T>> restoreCollections(String filename) {
  14. Map<String, List<T>> restoredData = new HashMap<>();
  16. try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
  17. String line;
  18. while ((line = reader.readLine()) != null) {
  19. line = line.trim(); // Remove leading/trailing whitespace
  21. if (line.isEmpty()) {
  22. continue; // Skip empty lines
  23. }
  25. // Parse the line to extract collection name and data
  26. String[] parts = line.split(":", 2); // Split into name and data
  27. if (parts.length != 2) {
  28. System.err.println("Invalid line format: " + line); //Log error
  29. continue; // Skip invalid lines
  30. }
  32. String collectionName = parts[0].trim();
  33. String dataString = parts[1].trim();
  35. List<T> collection = parseCollectionData(dataString);
  36. if (collection != null) {
  37. restoredData.put(collectionName, collection);
  38. } else {
  39. System.err.println("Failed to parse collection data for: " + collectionName); //Log error
  40. }
  41. }
  42. } catch (IOException e) {
  43. System.err.println("Error reading file: " + e.getMessage()); //Log error
  44. return null;
  45. }
  46. return restoredData;
  47. }
  49. /**
  50. * Parses a string containing collection data into a List of objects.
  51. * This is a placeholder and can be customized based on the specific data format.
  52. * @param dataString The string containing the collection data.
  53. * @param <T> The type of elements in the collections.
  54. * @return A list of objects, or null if parsing fails.
  55. */
  56. private <T> List<T> parseCollectionData(String dataString) {
  57. // Placeholder: Replace with your specific parsing logic
  58. // This example assumes comma-separated values
  59. if (dataString.isEmpty()) {
  60. return new ArrayList<>(); // Return empty list if data is empty
  61. }
  63. String[] values = dataString.split(",");
  64. List<T> collection = new ArrayList<>();
  65. for (String value : values) {
  66. try {
  67. //Attempt to parse as Integer, if fails, try Double, otherwise String
  68. try{
  69. collection.add((T)Integer.parseInt(value.trim()));
  71. } catch(NumberFormatException e){
  72. try{
  73. collection.add((T)Double.parseDouble(value.trim()));
  74. } catch(NumberFormatException e2) {
  75. collection.add((T)value.trim());
  76. }
  78. }
  79. } catch (Exception e) {
  80. System.err.println("Error parsing value: " + value); //Log error
  81. return null; // Return null if parsing fails
  82. }
  83. }
  84. return collection;
  85. }
  87. public static void main(String[] args) {
  88. CollectionRestorer restorer = new CollectionRestorer();
  89. Map<String, List<Integer>> restoredCollections = restorer.restoreCollections("data.txt");
  91. if (restoredCollections != null) {
  92. for (Map.Entry<String, List<Integer>> entry : restoredCollections.entrySet()) {
  93. System.out.println("Collection: " + entry.getKey() + ", Data: " + entry.getValue());
  94. }
  95. } else {
  96. System.err.println("Failed to restore collections.");
  97. }
  98. }
  99. }

Add your comment