Merge remote-tracking branch 'origin/NikitaUdinDev' into PavelLeonovTeamLead

Author: paledmi-java

.idea/gradle.xml

@@ -0,0 +1,13 @@
+### Генерация и валидация данных (Никита Юдин)
+
+Задачи:
+
+- Создать классы и методы, которые заполняют коллекцию выбранного класса:
+    - Генерация случайных объектов.
+    - Чтение объектов из файла.
+    - Ручной ввод объектов пользователем.
+- Сделать валидацию данных .
+- Работать с Builder, чтобы объекты создавались корректно.
+- Дополнительное задание 3: заполнение коллекций должно осуществляться посредством стримов. (Генерация данных тоже через стримы)
+- 3* Коллекции для заполнения должны быть кастомными.
+- (Использовать стрим для генерации данных, а результат перекладывать в кастомную коллекцию)

.idea/misc.xml

@@ -1,6 +1,6 @@
 package input;
 
-public interface CollectionInterface<T> {
+public interface CollectionInterface<T> extends Iterable<String>{
     boolean add(T car); // important
     boolean remove(T car); // important
     boolean removeAt(int index);

NikitaUdinReadMe

@@ -1,44 +1,191 @@
 package input;
 
-public class CustomCollection implements CollectionInterface{
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
 
-    @Override
-    public boolean add(Object car) {
-        return false;
+/**
+ * CustomCollection - кастомная реализация динамического массива с автоматическим расширением.
+ * Поддерживает хранение элементов любого типа, итерацию и базовые операции коллекции.
+ *
+ * <p>Коллекция использует внутренний массив для хранения элементов и автоматически
+ * расширяется при заполнении. Коэффициент расширения: {@value #GROWTH_FACTOR}.
+ *
+ * <p>Реализует интерфейс {@link Iterable} для поддержки for-each циклов и стримов.
+ *
+ * @param <T> тип элементов, хранимых в коллекции
+ */
+public class CustomCollection<T> implements Iterable<T> {
+    private static final float GROWTH_FACTOR = 1.5f;
+    private static final int DEFAULT_CAPACITY = 10;
+
+    private Object[] elements;
+    private int size;
+
+    public CustomCollection() {
+        this.elements = new Object[DEFAULT_CAPACITY];
     }
 
-    @Override
-    public boolean remove(Object car) {
-        return false;
+    public CustomCollection(int initialCapacity) {
+        if (initialCapacity <= 0) {
+            throw new IllegalArgumentException("Capacity cannot be less then 0");
+        }
+        this.elements = new Object[initialCapacity];
     }
 
-    @Override
-    public boolean removeAt(int index) {
-        return false;
+    // TODO Конструктор из существующей коллекции, копирует все элементы с ёмкостью равной ёмкости коллекции
+
+    public boolean add(T element) {
+        // Проверяем достаточно ли места для добавления
+        if (size == elements.length) {
+            // Если недостаточно, то увеличиваем размер списка
+            increaseCapacity(size + 1);
+        }
+        // Добавляем новый элемент на последнюю позицию
+        elements[size] = element;
+        // Увеличиваем число элементов в массиве
+        size++;
+        return true;
+    }
+
+    public void removeByIndex(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException("Index cannot be less then 0 or more then " + size);
+        }
+        // Вычисляем количество элементов, которые нужно сместить влево после удаления
+        int numToMove = size - index - 1;
+
+        if (numToMove > 0) {
+            // Используем System.arraycopy для эффективного копирования части массива:
+            // 1. elements - исходный массив
+            // 2. index+1 - начальная позиция в исходном массиве (элемент после удаляемого)
+            // 3. elements - целевой массив (тот же массив, копируем в себя)
+            // 4. index - начальная позиция в целевом массиве (на место удаляемого элемента)
+            // 5. numToMove - количество элементов для копирования
+            System.arraycopy(elements, index + 1, elements, index, numToMove);
+        }
+        // Уменьшаем size на 1 после копирования в конце массива остался "лишний" элемент и удаляем его
+        elements[--size] = null;
     }
 
-    @Override
     public void clear() {
+        for (int i = 0; i < size; i++) {
+            elements[i] = null;
+        }
+        size = 0;
+    }
 
+    public T get(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException("Index cannot be less then 0 or more then " + size);
+        }
+        return (T) elements[index];
     }
 
-    @Override
-    public Object get(int index) {
-        return null;
+    public T set(int index, T element) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException("Index cannot be less then 0 or more then " + size);
+        }
+
+        T old = (T) elements[index];
+        elements[index] = element;
+        return old;
     }
 
-    @Override
-    public boolean add(Object car, int index) {
-        return false;
+    /**
+     * Возвращает последовательный {@code Stream} с элементами этой коллекции в качестве источника.
+     *
+     * <p>Этот метод позволяет использовать функциональные операции над элементами коллекции.
+     *
+     * @return последовательный {@code Stream} элементов этой коллекции
+     */
+    public Stream<T> stream() {
+        return (Stream<T>) Arrays.stream(elements, 0, size);
+    }
+
+    /**
+     * Добавляет все элементы из указанной коллекции в конец этой коллекции.
+     *
+     * <p>Порядок элементов в целевой коллекции соответствует порядку,
+     * в котором они возвращаются итератором указанной коллекции.
+     *
+     * @param collection коллекция, содержащая элементы для добавления
+     * @return {@code true} если эта коллекция изменилась в результате вызова
+     */
+    public boolean addAll(Collection<? extends T> collection) {
+        // Проверяем, что переданная коллекция не null и не пустая
+        if (collection == null || collection.isEmpty()) {
+            // Возвращаем false, так как нечего добавлять
+            return false;
+        }
+
+        int requiredCapacity = size + collection.size();
+        if (requiredCapacity > elements.length) {
+            increaseCapacity(requiredCapacity);
+        }
+        for (T element : collection) {
+            // Добавляем элемент в конец массива
+            // elements[size] = element - добавляет элемент на текущую позицию
+            // size++ - увеличивает счетчик элементов
+            elements[size++] = element;
+        }
+        return true;
     }
 
-    @Override
     public int size() {
-        return 0;
+        return size;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
     }
 
     @Override
-    public boolean contains(Object car) {
-        return false;
+    public Iterator iterator() {
+        return new CustomArrayIterator();
+    }
+
+    // Внутренний клас для итератора
+    class CustomArrayIterator implements Iterator<T> {
+        private int cursor = 0; // текущая позиция
+        private int lastRet = -1; // индекс последнего возвращенного элемента
+
+        public CustomArrayIterator() {
+        }
+
+        public boolean hasNext() {
+            return cursor < size;
+        }
+
+        public T next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException("Элемент отсутствует");
+            }
+            lastRet = cursor;
+            T element = (T) elements[cursor];
+            cursor++;
+
+            return element;
+        }
+
+        public void remove() {
+            if (lastRet == -1) {
+                throw new IllegalStateException();
+            }
+            removeByIndex(lastRet);
+            cursor = lastRet;
+            lastRet = -1;
+        }
+    }
+
+    /**
+     * Увеличивает емкость внутреннего массива, чтобы обеспечить минимальную указанную емкость.
+     * @param minCapacity минимальная требуемая емкость
+     */
+    private void increaseCapacity(int minCapacity) {
+        int newCapacity = (int) Math.max(elements.length * GROWTH_FACTOR + 1, minCapacity);
+        Object[] newElements = new Object[newCapacity];
+        System.arraycopy(elements, 0, newElements, 0, size);
+        elements = newElements;
     }
 }

src/main/java/input/CollectionInterface.java

@@ -0,0 +1,17 @@
+package input.Strategy;
+
+import dto.Client;
+import input.CustomCollection;
+
+import java.io.IOException;
+
+/**
+ * Интерфейс стратегии для ввода данных клиентов.
+ * Реализует паттерн Стратегия для различных способов получения объектов {@link Client}.
+ * Каждая реализация представляет конкретный способ получения данных
+ * Реализации должны гарантировать, что возвращаемые объекты {@link Client}
+ * являются валидными
+ */
+public interface ClientInputStrategy {
+    CustomCollection<Client> getData() throws IOException;
+}

src/main/java/input/CustomCollection.java

@@ -0,0 +1,104 @@
+package input.Strategy;
+
+import dto.Client;
+import input.CustomCollection;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * Стратегия для чтения данных о клиентах из файла.
+ * Реализует интерфейс ClientInputStrategy для получения коллекции клиентов.
+ */
+public class FileReader implements ClientInputStrategy {
+    private final String filePath;
+
+    public FileReader(String filePath) {
+        this.filePath = filePath;
+    }
+
+    /**
+     * Читает данные о клиентах из файла и возвращает их в виде коллекции.
+     * Файл должен содержать строки в формате: Имя|Телефон|ID
+     * Телефон должен соответствовать формату: +7XXXXXXXXXX (11 цифр после +7)
+     *
+     * @return коллекция клиентов, прочитанных из файла
+     * @throws RuntimeException если файл не найден или произошла ошибка ввода-вывода
+     */
+    @Override
+    public CustomCollection<Client> getData() {
+        CustomCollection<Client> clients = new CustomCollection<>();
+        Path path = Paths.get(filePath);
+
+        if (!Files.exists(path)) {
+            throw new RuntimeException("File not found: " + filePath);
+        }
+
+        try (Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8)) {
+            lines
+                    .filter(line -> !line.trim().isEmpty())
+                    .map(this::parseToClient)
+                    .filter(Optional::isPresent)
+                    .map(Optional::get)
+                    .map(Client.ClientBuilder::build)
+                    .forEach(clients::add);
+
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        return clients;
+    }
+
+    /**
+     * Парсит строку из файла в объект ClientBuilder.
+     * Строка должна быть в формате: Имя|Телефон|ID
+     *
+     * @param line строка из файла для парсинга
+     * @return Optional содержащий ClientBuilder если строка валидна,
+     *         или пустой Optional если строка содержит ошибки формата
+     */
+    public Optional<Client.ClientBuilder> parseToClient(String line) {
+        try {
+            String[] parts = line.split("\\|");
+            if (parts.length != 3) {
+                throw new IllegalArgumentException("Invalid data format");
+            }
+            String name = parts[0].trim();
+            String phoneNumber = parts[1].trim();
+            int idNumber;
+
+            try {
+                idNumber = Integer.parseInt(parts[2].trim());
+            } catch (NumberFormatException e) {
+                System.out.println("[WARN] Missing line (ID is not a number): " + line);
+                return Optional.empty();
+            }
+
+            if (name.isEmpty()) {
+                System.out.println("[WARN] Missing line (name is empty): " + line);
+                return Optional.empty();
+            }
+
+            if (!phoneNumber.matches("^\\+7\\d{10}$")) {
+                System.out.println("[WARN] Missing line (invalid phone format): " + line);
+                return Optional.empty();
+            }
+
+            Client.ClientBuilder builder = new Client.ClientBuilder()
+                    .name(name)
+                    .phoneNumber(phoneNumber)
+                    .idNumber(idNumber);
+            return Optional.of(builder);
+
+        } catch (Exception e) {
+            System.out.println("[ERROR] Error processing line: " + line);
+            return Optional.empty();
+        }
+    }
+}

src/main/java/input/FileReader.java

@@ -1,4 +1,4 @@
-package input;
+package input.Strategy;
 
 public class ManualInputReader {
 }

src/main/java/input/Strategy/ClientInputStrategy.java

@@ -1,4 +1,4 @@
-package input;
+package input.Strategy;
 
 public class RandomDataGenerator {
 }