Реализовать класс сохранения данных в файл.

resources/data.csv

@@ -0,0 +1 @@
+id,type,name,status,description,epic

src/Main.java

@@ -1,13 +1,17 @@
+import manager.FileBackedTaskManager;
 import manager.Managers;
 import manager.TaskManager;
 import tasks.Task;
 import tasks.TaskStatus;
 import tasks.Subtask;
 import tasks.Epic;
 
+import java.io.File;
+
 public class Main {
 
     public static void main(String[] args) {
+        File dataFile = new File("resources/data.csv");
         TaskManager taskManager = Managers.getDefault();
 
         // 1. Создать таску
@@ -60,20 +64,37 @@ public static void main(String[] args) {
         System.out.println("История после просмотра второй подзадачи (4 задачи): " + taskManager.getHistory());
         System.out.println();
 
-        // 8. Удаляем таску (должна удалиться из истории)
+        // 8. Проверяем сохранение в файл.
+        System.out.println("Проверка работы с файлом:");
+        TaskManager loadedManager = FileBackedTaskManager.loadFromFile(dataFile);
+        System.out.println("Загруженные задачи: " + loadedManager.getTasks());
+        System.out.println("Загруженные эпики: " + loadedManager.getEpics());
+        System.out.println("Загруженные сабтаски: " + loadedManager.getSubtasks());
+        System.out.println();
+
+        // 9. Удаляем таску (должна удалиться из истории)
         System.out.println("Удаляем таску");
         taskManager.deleteTask(task.getId());
         System.out.println("История после удаления задачи (3 задачи): " + taskManager.getHistory());
         System.out.println();
 
-        // 9. Удаляем Эпик (должны удалиться эпик и его подзадачи из истории)
+        // 10. Удаляем Эпик (должны удалиться эпик и его подзадачи из истории)
         System.out.println("Удаляем Эпик");
         taskManager.deleteEpic(epic.getId());
         System.out.println("История после удаления эпика (должна быть пустая): " + taskManager.getHistory());
         System.out.println();
 
-        // 10. Проверяем историю после всех операций
+        // 11. Проверяем историю после всех операций.
         System.out.println("Финальная проверка истории");
         System.out.println("История: " + taskManager.getHistory());
+        System.out.println();
+
+        // 12. Проверяем удаление из файла.
+        System.out.println("Проверка работы с файлом:");
+        TaskManager newLoadedManager = FileBackedTaskManager.loadFromFile(dataFile);
+        System.out.println("Загруженные задачи: " + newLoadedManager.getTasks());
+        System.out.println("Загруженные эпики: " + newLoadedManager.getEpics());
+        System.out.println("Загруженные сабтаски: " + newLoadedManager.getSubtasks());
+        System.out.println();
     }
 }

src/manager/CsvFormatter.java

@@ -0,0 +1,59 @@
+package manager;
+import tasks.*;
+
+public class CsvFormatter {
+
+    public static final String CSV_HEADER = "id,type,name,status,description,epic";
+
+
+    // Преобразование задачи в CSV строку
+    public static String toString(Task task) {
+        if (task == null) return "";
+
+        String epicField = "";
+        if (task.getType() == TaskType.SUBTASK) {
+            epicField = String.valueOf(((Subtask) task).getEpicId());
+        }
+
+        return String.join(",",
+                String.valueOf(task.getId()),
+                task.getType().name(),
+                task.getName(),
+                task.getTaskStatus().name(),
+                task.getDescription(),
+                epicField);
+    }
+
+    // Создание задачи из CSV строки
+    public static Task fromString(String value) {
+        if (value == null || value.isEmpty()) return null;
+
+        String[] fields = value.split(",");
+        if (fields.length < 5) return null;
+
+        int id = Integer.parseInt(fields[0]);
+        TaskType type = TaskType.valueOf(fields[1]);
+        String name = fields[2];
+        TaskStatus status = TaskStatus.valueOf(fields[3]);
+        String description = fields[4];
+
+        switch (type) {
+            case TASK:
+                return new Task(id, name, description, status);
+            case EPIC:
+                Epic epic = new Epic(name, description);
+                epic.setId(id);
+                epic.setTaskStatus(status);
+                return epic;
+            case SUBTASK:
+                int epicId = fields.length > 5 ? Integer.parseInt(fields[5]) : 0;
+                Subtask subtask = new Subtask(name, description, status, epicId);
+                subtask.setId(id);
+                return subtask;
+            default:
+                return null;
+        }
+    }
+}
+
+

src/manager/FileBackedTaskManager.java

@@ -0,0 +1,209 @@
+package manager;
+
+import tasks.*;
+import manager.exceptions.ManagerSaveException;
+import manager.exceptions.ManagerLoadException;
+import java.io.*;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+
+public class FileBackedTaskManager extends InMemoryTaskManager {
+
+    private final File file;
+
+
+    public FileBackedTaskManager(File file, HistoryManager historyManager) {
+        this.file = file;
+        this.historyManager = historyManager;
+    }
+
+    // Загрузка данных из файла.
+    public static FileBackedTaskManager loadFromFile(File file) {
+        FileBackedTaskManager manager = new FileBackedTaskManager(file, Managers.getDefaultHistory());
+
+        if (file.exists() && file.length() > 0) {
+            manager.load();
+        }
+        return manager;
+    }
+
+
+
+    // Переопределенные методы Task
+    @Override
+    public Task getTask(int id) {
+        Task task = super.getTask(id);
+        save();
+        return task;
+    }
+
+    @Override
+    public Task createTask(Task task) {
+        Task createdTask = super.createTask(task);
+        save();
+        return createdTask;
+    }
+
+    @Override
+    public Task updateTask(Task task) {
+        Task updatedTask = super.updateTask(task);
+        save();
+        return updatedTask;
+    }
+
+    @Override
+    public Task deleteTask(int id) {
+        Task deletedTask = super.deleteTask(id);
+        save();
+        return deletedTask;
+    }
+
+    // Переопределенные методы Subtask
+    @Override
+    public Subtask getSubtasks(int id) {
+        Subtask subtask = super.getSubtasks(id);
+        save();
+        return subtask;
+    }
+
+    @Override
+    public Subtask createSubtask(Subtask subtask) {
+        Subtask createdSubtask = super.createSubtask(subtask);
+        save();
+        return createdSubtask;
+    }
+
+    @Override
+    public Subtask updateSubtask(Subtask subtask) {
+        Subtask updatedSubtask = super.updateSubtask(subtask);
+        save();
+        return updatedSubtask;
+    }
+
+    @Override
+    public Subtask deleteSubtask(int id) {
+        Subtask deletedSubtask = super.deleteSubtask(id);
+        save();
+        return deletedSubtask;
+    }
+
+    // Переопределенные методы Epic
+    @Override
+    public Epic getEpic(int id) {
+        Epic epic = super.getEpic(id);
+        save();
+        return epic;
+    }
+
+    @Override
+    public Epic createEpic(Epic epic) {
+        Epic createdEpic = super.createEpic(epic);
+        save();
+        return createdEpic;
+    }
+
+    @Override
+    public Epic updateEpic(Epic epic) {
+        Epic updatedEpic = super.updateEpic(epic);
+        save();
+        return updatedEpic;
+    }
+
+    @Override
+    public Epic deleteEpic(int id) {
+        Epic deletedEpic = super.deleteEpic(id);
+        save();
+        return deletedEpic;
+    }
+
+    // Переопределенные методы удаления всех задач
+    @Override
+    public void deleteAllTasks() {
+        super.deleteAllTasks();
+        save();
+    }
+
+    @Override
+    public void deleteAllSubtasks() {
+        super.deleteAllSubtasks();
+        save();
+    }
+
+    @Override
+    public void deleteAllEpics() {
+        super.deleteAllEpics();
+        save();
+    }
+
+    @Override
+    public void deleteAll() {
+        super.deleteAll();
+        save();
+    }
+
+
+    // Загрузка данных
+        private void load() {
+            try {
+                String content = Files.readString(file.toPath());
+                String[] lines = content.split("\n");
+
+                if (lines.length < 2) return;
+
+                int maxId = 0;
+
+                for (int i = 1; i < lines.length; i++) {
+                    Task task = CsvFormatter.fromString(lines[i]);
+                    if (task == null) continue;
+
+                    if (task.getId() > maxId) {
+                        maxId = task.getId();
+                    }
+
+                    switch (task.getType()) {
+                        case TASK:
+                            tasks.put(task.getId(), task);
+                            break;
+                        case EPIC:
+                            epics.put(task.getId(), (Epic) task);
+                            break;
+                        case SUBTASK:
+                            Subtask subtask = (Subtask) task;
+                            subtasks.put(task.getId(), subtask);
+                            Epic epic = epics.get(subtask.getEpicId());
+                            if (epic != null) {
+                                epic.addSubtaskId(subtask.getId());
+                            }
+                            break;
+                    }
+                }
+                generatorId = maxId + 1;
+            } catch (IOException e) {
+                throw new ManagerLoadException("Не удалось загрузить задачи из файла: " + file.getPath(), e);
+            }
+        }
+
+    // Сохранение данных в файл
+    private void save() throws ManagerSaveException {
+        try (FileWriter writer = new FileWriter(file)) {
+            writer.write(CsvFormatter.CSV_HEADER + "\n"); // Запись заголовка
+            for (Task task : getAllTasks()) {
+                writer.write(CsvFormatter.toString(task) + "\n"); // Запись задач
+            }
+        } catch (IOException e) {
+            throw new ManagerSaveException("Ошибка сохранения файла", e);
+        }
+    }
+
+    // Получение всех задач.
+    private List<Task> getAllTasks() {
+        List<Task> tasks = new ArrayList<>();
+        tasks.addAll(getTasks());
+        tasks.addAll(getEpics());
+        tasks.addAll(getSubtasks());
+        return tasks;
+    }
+}
+
+

src/manager/InMemoryTaskManager.java

@@ -13,11 +13,15 @@
 
 public class InMemoryTaskManager implements TaskManager {
 
-    private Map<Integer, Task> tasks = new HashMap<>();
-    private Map<Integer, Subtask> subtasks = new HashMap<>();
-    private Map<Integer, Epic> epics = new HashMap<>();
-    private int generatorId = 1;
-    private HistoryManager historyManager = Managers.getDefaultHistory();
+    protected final Map<Integer, Task> tasks = new HashMap<>();
+    protected final Map<Integer, Subtask> subtasks = new HashMap<>();
+    protected final Map<Integer, Epic> epics = new HashMap<>();
+    protected int generatorId = 1;
+    protected HistoryManager historyManager;
+
+    public InMemoryTaskManager() {
+        this.historyManager = Managers.getDefaultHistory();
+    }
 
 
     // Методы для Task
@@ -269,6 +273,6 @@ private void updateEpicStatus(Epic epic) {
     private int getNextId() {
         return generatorId++;
     }
-
 }
 
+

src/manager/Managers.java

@@ -1,12 +1,21 @@
 package manager;
 
+import java.io.File;
+
 public class Managers {
 
     private Managers() {
     }
 
     public static TaskManager getDefault() {
-        return new InMemoryTaskManager();
+        String path = "resources" + File.separator + "data.csv";
+        File file = new File(path);
+
+        File dir = new File("resources");
+        if (!dir.exists()) {
+            dir.mkdir();
+        }
+        return new FileBackedTaskManager(file, getDefaultHistory());
     }
 
     public static HistoryManager getDefaultHistory() {

src/manager/exceptions/ManagerLoadException.java

@@ -0,0 +1,12 @@
+package manager.exceptions;
+
+public class ManagerLoadException extends RuntimeException {
+
+    public ManagerLoadException(String message) {
+        super(message);
+    }
+
+    public ManagerLoadException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}