1. import java.util.ArrayList;
  2. import java.util.HashMap;
  3. import java.util.List;
  4. import java.util.Map;
  5. import java.util.regex.Matcher;
  6. import java.util.regex.Pattern;
  8. public class DataConverter {
  10. /**
  11. * Converts a string from legacy format to a modern format.
  12. *
  13. * @param legacyData The data in the legacy format. Example: "name: John Doe,age:30,city:New York"
  14. * @return A map representing the data in the modern format. Returns an empty map if input is null or empty.
  15. */
  16. public static Map<String, String> convertLegacyToModern(String legacyData) {
  17. Map<String, String> modernData = new HashMap<>();
  19. if (legacyData == null || legacyData.trim().isEmpty()) {
  20. return modernData;
  21. }
  23. String[] pairs = legacyData.split(","); // Split into key-value pairs
  25. for (String pair : pairs) {
  26. String[] parts = pair.split(":", 2); // Split into key and value, limit to 2 splits to handle colons in values
  27. if (parts.length == 2) {
  28. String key = parts[0].trim();
  29. String value = parts[1].trim();
  30. modernData.put(key, value);
  31. }
  32. }
  34. return modernData;
  35. }
  37. /**
  38. * Converts a list of strings from a comma-separated format to a list of individual elements.
  39. *
  40. * @param commaSeparatedData A string containing comma-separated elements. Example: "item1,item2,item3"
  41. * @return A list of strings representing the individual elements. Returns an empty list if input is null or empty.
  42. */
  43. public static List<String> convertCommaSeparatedToList(String commaSeparatedData) {
  44. List<String> list = new ArrayList<>();
  46. if (commaSeparatedData == null || commaSeparatedData.trim().isEmpty()) {
  47. return list;
  48. }
  50. String[] elements = commaSeparatedData.split(",");
  51. for (String element : elements) {
  52. list.add(element.trim());
  53. }
  55. return list;
  56. }
  58. /**
  59. * Converts a string representing a date in "yyyy-MM-dd" format to "MM/dd/yyyy" format.
  60. *
  61. * @param dateString The date string in "yyyy-MM-dd" format.
  62. * @return The date string in "MM/dd/yyyy" format, or null if the input is invalid.
  63. */
  64. public static String convertDateFormat(String dateString) {
  65. if (dateString == null || dateString.trim().isEmpty()) {
  66. return null;
  67. }
  69. try {
  70. String[] parts = dateString.split("-");
  71. if (parts.length != 3) {
  72. return null; // Invalid format
  73. }
  75. String year = parts[0];
  76. String month = parts[1];
  77. String day = parts[2];
  79. return String.format("%02d/%02d/%s", Integer.parseInt(month), Integer.parseInt(day), year);
  80. } catch (NumberFormatException e) {
  81. return null; // Invalid date values
  82. }
  83. }
  85. /**
  86. * Converts a string containing a pattern to a formatted string using the pattern.
  87. * @param data The data to format.
  88. * @param pattern The format pattern.
  89. * @return The formatted string.
  90. */
  91. public static String formatString(String data, String pattern) {
  92. if (data == null || pattern == null) {
  93. return "";
  94. }
  95. try {
  96. return String.format(pattern, data);
  97. } catch (Exception e) {
  98. return data;
  99. }
  100. }
  103. public static void main(String[] args) {
  104. // Example usage
  105. Map<String, String> legacyData = convertLegacyToModern("name: John Doe,age:30,city:New York");
  106. System.out.println(legacyData); // Expected: {name=John Doe, age=30, city=New York}
  108. List<String> commaSeparatedList = convertCommaSeparatedToList("item1,item2,item3");
  109. System.out.println(commaSeparatedList); // Expected: [

Add your comment