Lesson 41 (set) for review

src/com/walking/lesson41_set/task1/Main.java

@@ -1,5 +1,11 @@
 package com.walking.lesson41_set.task1;
 
+import com.walking.lesson40_queue2.model.Task;
+import com.walking.lesson40_queue2.service.TaskService;
+
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Реализуйте задачу
  * <a href="https://github.com/KFalcon2022/practical-tasks/tree/master/src/com/walking/lesson40_queue2">...</a>,
@@ -9,5 +15,36 @@
  */
 public class Main {
     public static void main(String[] args) {
+        TaskService taskService = new TaskService(getTaskList());
+
+        taskService.acceptSingleTask(new Task("Fourth"));
+        taskService.executeSingleTask();
+
+        if (taskService.haveTask()) {
+            taskService.cancelNextTask();
+        }
+
+        taskService.executeMultipleTasks(2);
+        taskService.acceptAllTasks(getTaskList());
+
+        List<Task> canceledTasks = taskService.cancelMultipleTasks(2);
+        System.out.println("Canceled tasks:");
+
+        for (Task canceledTask : canceledTasks) {
+            System.out.println(canceledTask.getName());
+        }
+
+        Task nextTask = taskService.lookNextTask();
+        System.out.println("Next task: " + nextTask.getName());
+    }
+
+    public static List<Task> getTaskList() {
+        List<Task> tasks = new ArrayList<>();
+
+        tasks.add(new Task("First"));
+        tasks.add(new Task("Second"));
+        tasks.add(new Task("Third"));
+
+        return tasks;
     }
-}
+}

src/com/walking/lesson41_set/task1/model/Task.java

@@ -0,0 +1,49 @@
+package com.walking.lesson41_set.task1.model;
+
+import java.time.Instant;
+import java.util.Objects;
+
+public class Task implements Comparable<Task> {
+    private final String name;
+    private Instant acceptedAt;
+
+    public Task(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Instant getAcceptedAt() {
+        return acceptedAt;
+    }
+
+    public void setAcceptedAt(Instant acceptedAt) {
+        this.acceptedAt = acceptedAt;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        Task task = (Task) o;
+
+        return Objects.equals(name, task.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return name != null ? name.hashCode() : 0;
+    }
+
+    @Override
+    public int compareTo(Task o) {
+        return acceptedAt.compareTo(o.getAcceptedAt());
+    }
+}

src/com/walking/lesson41_set/task1/model/TaskStatus.java

@@ -0,0 +1,12 @@
+package com.walking.lesson41_set.task1.model;
+
+public enum TaskStatus {
+    ACCEPTED,
+    EXECUTED,
+    CANCELED;
+
+    @Override
+    public String toString() {
+        return this.name().toLowerCase();
+    }
+}

src/com/walking/lesson41_set/task1/service/TaskService.java

@@ -0,0 +1,109 @@
+package com.walking.lesson41_set.task1.service;
+
+import com.walking.lesson41_set.task1.model.Task;
+import com.walking.lesson41_set.task1.model.TaskStatus;
+import com.walking.lesson41_set.task1.util.Logger;
+
+import java.time.Instant;
+import java.util.*;
+
+public class TaskService {
+    private final NavigableSet<Task> tasks;
+    private final Logger logger;
+
+    public TaskService() {
+        this.tasks = new TreeSet<>();
+        this.logger = new Logger();
+    }
+
+    public TaskService(Collection<? extends Task> incomingTasks) {
+        this.tasks = new TreeSet<>(incomingTasks);
+        this.logger = new Logger();
+
+        for (Task incomingTask : incomingTasks) {
+            logger.log(getTaskStatusMessage(incomingTask, TaskStatus.ACCEPTED));
+        }
+    }
+
+    public List<Task> getAllTasks() {
+        return List.copyOf(tasks);
+    }
+
+    public boolean acceptSingleTask(Task acceptedTask) {
+        if (tasks.add(acceptedTask)) {
+            acceptedTask.setAcceptedAt(Instant.now());
+            logger.log(getTaskStatusMessage(acceptedTask, TaskStatus.ACCEPTED));
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public boolean acceptAllTasks(Collection<? extends Task> incomingTasks) {
+        if (tasks.addAll(incomingTasks)) {
+            for (Task acceptedTask : incomingTasks) {
+                acceptedTask.setAcceptedAt(Instant.now());
+                logger.log(getTaskStatusMessage(acceptedTask, TaskStatus.ACCEPTED));
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public Task executeSingleTask() {
+        Task executedTask = tasks.pollFirst();
+
+        if (executedTask != null) {
+            logger.log(getTaskStatusMessage(executedTask, TaskStatus.EXECUTED));
+            executedTask.setAcceptedAt(null);
+        }
+
+        return executedTask;
+    }
+
+    public List<Task> executeMultipleTasks(int taskCount) {
+        List<Task> executedTasks = new ArrayList<>();
+
+        for (int i = 0; i < taskCount; i++) {
+            executedTasks.add(executeSingleTask());
+        }
+
+        return executedTasks;
+    }
+
+    public Task cancelNextTask() {
+        Task canceledTask = tasks.pollFirst();
+
+        if (canceledTask != null) {
+            logger.log(getTaskStatusMessage(canceledTask, TaskStatus.CANCELED));
+            canceledTask.setAcceptedAt(null);
+        }
+
+        return canceledTask;
+    }
+
+    public List<Task> cancelMultipleTasks(int taskCount) {
+        List<Task> canceledTasks = new ArrayList<>();
+
+        for (int i = 0; i < taskCount; i++) {
+            canceledTasks.add(cancelNextTask());
+        }
+
+        return canceledTasks;
+    }
+
+    public Task lookNextTask() {
+        return tasks.isEmpty() ? null : tasks.first();
+    }
+
+    public boolean haveTask() {
+        return !tasks.isEmpty();
+    }
+
+    private String getTaskStatusMessage(Task task, TaskStatus status) {
+        return "Task <%s> %s".formatted(task.getName(), status);
+    }
+}

src/com/walking/lesson41_set/task1/util/Logger.java

@@ -0,0 +1,7 @@
+package com.walking.lesson41_set.task1.util;
+
+public class Logger {
+    public void log(String message) {
+        System.out.println(message);
+    }
+}

src/com/walking/lesson41_set/task2/Main.java

@@ -1,11 +1,37 @@
 package com.walking.lesson41_set.task2;
 
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Scanner;
+import java.util.Set;
+
 /**
  * Реализуйте задачу
  * <a href="https://github.com/KFalcon2022/practical-tasks/tree/master/src/com/walking/lesson26_string_types/task2">...</a>,
  * используя Set.
  */
 public class Main {
     public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.println("Введите строку, содержашую слова, разделенные пробелом:");
+
+        String input = scanner.nextLine();
+
+        scanner.close();
+
+        int amountUniqueWords = countUniqueWords(input);
+
+        System.out.printf("Количество уникальных слов в строке: %d\n", amountUniqueWords);
+    }
+
+    private static int countUniqueWords(String allWords) {
+        String[] splittedWords = allWords.trim()
+                                         .toLowerCase()
+                                         .split(" ");
+
+        Set<String> uniqueWords = new HashSet<>(Arrays.asList(splittedWords));
+
+        return uniqueWords.size();
     }
-}
+}