1. import java.io.File;
  2. import java.io.IOException;
  4. public class DirectoryManager {
  6. /**
  7. * Creates a directory, handling potential exceptions and ensuring defensive behavior.
  8. * @param path The path to the directory to create.
  9. * @return True if the directory was created successfully, false otherwise.
  10. */
  11. public static boolean createDirectory(String path) {
  12. File dir = new File(path);
  14. // Defensive check: Check if the path is null or empty.
  15. if (path == null || path.trim().isEmpty()) {
  16. System.err.println("Error: Path cannot be null or empty.");
  17. return false;
  18. }
  20. // Defensive check: Check if the parent directory exists.
  21. File parentDir = dir.getParentFile();
  22. if (parentDir != null && !parentDir.exists()) {
  23. System.err.println("Error: Parent directory does not exist.");
  24. return false;
  25. }
  27. try {
  28. if (dir.mkdir()) {
  29. System.out.println("Directory created successfully: " + path);
  30. return true;
  31. } else {
  32. System.err.println("Error: Failed to create directory: " + path);
  33. return false;
  34. }
  35. } catch (SecurityException e) {
  36. System.err.println("Error: Insufficient permissions to create directory: " + path);
  37. e.printStackTrace();
  38. return false;
  39. } catch (Exception e) {
  40. System.err.println("Error creating directory: " + path + ". " + e.getMessage());
  41. e.printStackTrace();
  42. return false;
  43. }
  44. }
  46. /**
  47. * Checks if a directory exists, handling potential exceptions.
  48. * @param path The path to the directory.
  49. * @return True if the directory exists, false otherwise.
  50. */
  51. public static boolean directoryExists(String path) {
  52. File dir = new File(path);
  53. if (path == null || path.trim().isEmpty()) {
  54. System.err.println("Error: Path cannot be null or empty.");
  55. return false;
  56. }
  57. return dir.exists() && dir.isDirectory();
  58. }
  60. /**
  61. * Deletes a directory and its contents recursively, with defensive checks.
  62. * @param path The path to the directory to delete.
  63. * @return True if the directory was deleted successfully, false otherwise.
  64. */
  65. public static boolean deleteDirectory(String path) {
  66. File dir = new File(path);
  67. if (path == null || path.trim().isEmpty()) {
  68. System.err.println("Error: Path cannot be null or empty.");
  69. return false;
  70. }
  72. if (!dir.exists() || !dir.isDirectory()) {
  73. System.err.println("Error: Directory does not exist or is not a directory: " + path);
  74. return false;
  75. }
  77. try {
  78. if (dir.delete()) {
  79. System.out.println("Directory deleted successfully: " + path);
  80. return true;
  81. } else {
  82. System.err.println("Error: Failed to delete directory: " + path);
  83. return false;
  84. }
  85. } catch (SecurityException e) {
  86. System.err.println("Error: Insufficient permissions to delete directory: " + path);
  87. e.printStackTrace();
  88. return false;
  89. } catch (Exception e) {
  90. System.err.println("Error deleting directory: " + path + ". " + e.getMessage());
  91. e.printStackTrace();
  92. return false;
  93. }
  94. }
  96. public static void main(String[] args) {
  97. // Example usage
  98. String dirPath = "test_dir";
  100. //Create Directory
  101. if (createDirectory(dirPath)) {
  102. System.out.println("Directory created.");
  103. } else {
  104. System.out.println("Directory creation failed.");
  105. }
  107. //Check if directory exists
  108. if (directoryExists(dirPath)) {
  109. System.out.println("Directory exists.");
  110. } else {
  111. System.out.println("Directory does not exist.");
  112. }
  114. //Delete Directory
  115. if (deleteDirectory(dirPath)) {
  116. System.out.println("Directory deleted.");
  117. } else {
  118. System.out.println("Directory deletion failed.");
  119. }
  120. }
  121. }

Add your comment