1. import java.io.Serializable;
  2. import java.util.ArrayList;
  3. import java.util.HashMap;
  4. import java.util.List;
  5. import java.util.Map;
  7. public class ListSerializer {
  9. /**
  10. * Serializes a list of objects to a string representation.
  11. * Uses default values for null elements.
  12. *
  13. * @param list The list to serialize.
  14. * @param <T> The type of objects in the list. Must be Serializable.
  15. * @return A string representation of the list. Returns null if list is null.
  16. */
  17. public static <T extends Serializable> String serializeList(List<T> list) {
  18. if (list == null) {
  19. return null;
  20. }
  22. StringBuilder sb = new StringBuilder();
  23. sb.append("[");
  24. for (int i = 0; i < list.size(); i++) {
  25. Object element = list.get(i);
  26. if (element == null) {
  27. sb.append("null"); // Use "null" as default value.
  28. } else {
  29. sb.append(element.toString());
  30. }
  32. if (i < list.size() - 1) {
  33. sb.append(", ");
  34. }
  35. }
  36. sb.append("]");
  37. return sb.toString();
  38. }
  40. /**
  41. * Deserializes a string representation of a list back into a list of objects.
  42. * Handles "null" strings as null elements.
  43. *
  44. * @param listString The string representation of the list.
  45. * @param <T> The type of objects in the list. Must be Serializable.
  46. * @return A list of objects. Returns an empty list if listString is null or empty.
  47. * @throws IllegalArgumentException if the listString format is invalid.
  48. */
  49. public static <T extends Serializable> List<T> deserializeList(String listString) {
  50. List<T> list = new ArrayList<>();
  51. if (listString == null || listString.isEmpty()) {
  52. return list; // Return empty list for null or empty string
  53. }
  55. listString = listString.trim(); // Remove leading/trailing whitespace
  57. if (listString.startsWith("[") && listString.endsWith("]")) {
  58. listString = listString.substring(1, listString.length() - 1); // Remove brackets
  60. String[] elements = listString.split(",");
  61. for (String element : elements) {
  62. element = element.trim();
  63. if (element.equals("null")) {
  64. list.add(null); // Add null if string equals "null"
  65. } else {
  66. try {
  67. list.add((T) deserializeObject(element));
  68. } catch (Exception e) {
  69. throw new IllegalArgumentException("Invalid list format: " + element, e);
  70. }
  71. }
  72. }
  73. } else {
  74. throw new IllegalArgumentException("Invalid list format.");
  75. }
  77. return list;
  78. }
  80. private static <T extends Serializable> T deserializeObject(String element) throws IllegalArgumentException {
  81. try {
  82. // Attempt to parse the element as an Integer. You can extend this to handle other types.
  83. return (T) Integer.parseInt(element);
  84. } catch (NumberFormatException e) {
  85. try{
  86. return (T) Double.parseDouble(element);
  87. } catch (NumberFormatException e2){
  88. return (T) new String(element);
  89. }
  91. }
  92. }
  96. public static void main(String[] args) {
  97. // Example Usage
  98. List<String> myList = new ArrayList<>();
  99. myList.add("apple");
  100. myList.add(null);
  101. myList.add("banana");
  103. String serializedList = serializeList(myList);
  104. System.out.println("Serialized List: " + serializedList);
  106. List<String> deserializedList = deserializeList(serializedList);
  107. System.out.println("Deserialized List: " + deserializedList);
  109. List<Integer> intList = new ArrayList<>();
  110. intList.add(1);
  111. intList.add(2);
  112. intList.add(null);
  113. String serializedIntList = serializeList(intList);
  114. System.out.println("Serialized Integer List: " + serializedIntList);
  116. List<Integer> deserializedIntList = deserializeList(serializedIntList);
  117. System.

Add your comment