From 6ea5e07f94c388db793fe64b11e9a77a30ef8b91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D1=8F=D1=87=D0=B5=D1=81=D0=BB=D0=B0=D0=B2=20=D0=A2?=
 =?UTF-8?q?=D0=B8=D1=85=D0=BE=D0=BD=D0=BE=D0=B2?= <sl-tx@yandex.ru>
Date: Mon, 19 Dec 2022 16:11:49 +0300
Subject: [PATCH] Int Array

---
 src/main/java/org/example/App.java            |  78 +++++-
 src/main/java/org/example/IntegerList.java    |  82 +++++++
 .../java/org/example/IntegerListImpl.java     | 222 ++++++++++++++++++
 .../java/org/example/IntegerListImplTest.java | 182 ++++++++++++++
 4 files changed, 558 insertions(+), 6 deletions(-)
 create mode 100644 src/main/java/org/example/IntegerList.java
 create mode 100644 src/main/java/org/example/IntegerListImpl.java
 create mode 100644 src/test/java/org/example/IntegerListImplTest.java

diff --git a/src/main/java/org/example/App.java b/src/main/java/org/example/App.java
index 5f21d2e..1628ed8 100644
--- a/src/main/java/org/example/App.java
+++ b/src/main/java/org/example/App.java
@@ -1,13 +1,79 @@
 package org.example;
 
+import java.util.Arrays;
+import java.util.Random;
+import java.util.stream.Collectors;
+
 /**
  * Hello world!
- *
  */
-public class App 
-{
-    public static void main( String[] args )
-    {
-        System.out.println( "Hello World!" );
+public class App {
+    public static Integer[] genArr() {
+        Random rand = new Random();
+        Integer[] ar1 = new Integer[10000];
+        for (int i = 0; i < ar1.length; i++) {
+            ar1[i] = rand.nextInt(1000);
+        }
+        return ar1;
+    }
+
+    public static void sortBubble(Integer[] arr) {
+        for (int i = 0; i < arr.length - 1; i++) {
+            for (int j = 0; j < arr.length - 1 - i; j++) {
+                if (arr[j] > arr[j + 1]) {
+                    swapElements(arr, j, j + 1);
+                }
+            }
+        }
+    }
+
+    public static void sortSelection(Integer[] arr) {
+        for (int i = 0; i < arr.length - 1; i++) {
+            int minElementIndex = i;
+            for (int j = i + 1; j < arr.length; j++) {
+                if (arr[j] < arr[minElementIndex]) {
+                    minElementIndex = j;
+                }
+            }
+            swapElements(arr, i, minElementIndex);
+        }
+    }
+
+    private static void swapElements(Integer[] arr, int i, int minElementIndex) {
+        Integer buf = arr[i];
+        arr[i] = arr[minElementIndex];
+        arr[minElementIndex] = buf;
+    }
+
+    public static void sortInsertion(Integer[] arr) {
+        for (int i = 1; i < arr.length; i++) {
+            Integer temp = arr[i];
+            int j = i;
+            while (j > 0 && arr[j - 1] >= temp) {
+                arr[j] = arr[j - 1];
+                j--;
+            }
+            arr[j] = temp;
+        }
+    }
+
+    public static void main(String[] args) {
+        long start;
+        Integer[] ar1 = genArr();
+        Integer[] ar2 = ar1.clone();
+        Integer[] ar3 = ar1.clone();
+        Integer[] ar4 = ar1.clone();
+        start = System.currentTimeMillis();
+        Arrays.sort(ar1);
+        System.out.println(System.currentTimeMillis() - start);
+        start = System.currentTimeMillis();
+        sortBubble(ar2);
+        System.out.println(System.currentTimeMillis() - start);
+        start = System.currentTimeMillis();
+        sortSelection(ar3);
+        System.out.println(System.currentTimeMillis() - start);
+        start = System.currentTimeMillis();
+        sortInsertion(ar4);
+        System.out.println(System.currentTimeMillis() - start);
     }
 }
diff --git a/src/main/java/org/example/IntegerList.java b/src/main/java/org/example/IntegerList.java
new file mode 100644
index 0000000..744a488
--- /dev/null
+++ b/src/main/java/org/example/IntegerList.java
@@ -0,0 +1,82 @@
+package org.example;
+
+public interface IntegerList {
+
+    // Добавление элемента.
+    // Вернуть добавленный элемент
+    // в качестве результата выполнения.
+    Integer add(Integer item);
+
+    // Добавление элемента
+    // на определенную позицию списка.
+    // Если выходит за пределы фактического
+    // количества элементов или массива,
+    // выбросить исключение.
+    // Вернуть добавленный элемент
+    // в качестве результата выполнения.
+    Integer add(int index, Integer item);
+
+    // Установить элемент
+    // на определенную позицию,
+    // затерев существующий.
+    // Выбросить исключение,
+    // если индекс больше
+    // фактического количества элементов
+    // или выходит за пределы массива.
+    Integer set(int index, Integer item);
+
+    // Удаление элемента.
+    // Вернуть удаленный элемент
+    // или исключение, если подобный
+    // элемент отсутствует в списке.
+    Integer remove(Integer item);
+
+    // Удаление элемента по индексу.
+    // Вернуть удаленный элемент
+    // или исключение, если подобный
+    // элемент отсутствует в списке.
+    Integer remove(int index);
+
+    // Проверка на существование элемента.
+    // Вернуть true/false;
+    boolean contains(Integer item);
+
+    // Поиск элемента.
+    // Вернуть индекс элемента
+    // или -1 в случае отсутствия.
+    int indexOf(Integer item);
+
+    // Поиск элемента с конца.
+    // Вернуть индекс элемента
+    // или -1 в случае отсутствия.
+    int lastIndexOf(Integer item);
+
+    // Получить элемент по индексу.
+    // Вернуть элемент или исключение,
+    // если выходит за рамки фактического
+    // количества элементов.
+    Integer get(int index);
+
+    // Сравнить текущий список с другим.
+    // Вернуть true/false или исключение,
+    // если передан null.
+    boolean equals(IntegerList otherList);
+
+    // Вернуть фактическое количество элементов.
+    int size();
+
+    // Вернуть true,
+    // если элементов в списке нет,
+    // иначе false.
+    boolean isEmpty();
+
+    // Удалить все элементы из списка.
+    void clear();
+
+    // Создать новый массив
+    // из строк в списке
+    // и вернуть его.
+    Integer[] toArray();
+
+    void sort();
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/IntegerListImpl.java b/src/main/java/org/example/IntegerListImpl.java
new file mode 100644
index 0000000..605027a
--- /dev/null
+++ b/src/main/java/org/example/IntegerListImpl.java
@@ -0,0 +1,222 @@
+package org.example;
+
+import java.util.Arrays;
+
+public class IntegerListImpl implements IntegerList {
+
+    private final Integer[] array;
+    private final int size;
+
+    public IntegerListImpl(int size) {
+        this.size = size;
+        this.array = new Integer[size];
+    }
+
+    @Override
+    public Integer add(Integer item) {
+        if (array[size - 1] != null) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (item == null) {
+            throw new IllegalArgumentException();
+        }
+        for (int i = 0; i < size; i++) {
+            if (array[i] == null) {
+                array[i] = item;
+                return item;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Integer add(int index, Integer item) {
+        if (index >= size - 1 || index < 0 || array[size - 1] != null) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (item == null) {
+            throw new IllegalArgumentException();
+        }
+        for (int i = size - 1; i >= index; i--) {
+            if (array[i] != null) {
+                array[i + 1] = array[i];
+            }
+        }
+        array[index] = item;
+        return item;
+    }
+
+    @Override
+    public Integer set(int index, Integer item) {
+        if (index >= size || index < 0) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (item == null) {
+            throw new IllegalArgumentException();
+        }
+        array[index] = item;
+        return item;
+    }
+
+    @Override
+    public Integer remove(Integer item) {
+        if (item == null) {
+            throw new IllegalArgumentException();
+        }
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] != null && array[i].equals(item)) {
+                return remove(i);
+            }
+        }
+        throw new IllegalArgumentException();
+    }
+
+    @Override
+    public Integer remove(int index) {
+        if (index >= size || index < 0) {
+            throw new IndexOutOfBoundsException();
+        }
+        Integer ret = array[index];
+        if (ret == null) {
+            throw new IllegalArgumentException();
+        }
+        for (int i = size - 1; i >= index; i--) {
+            if (i == size - 1) {
+                array[i] = null;
+            } else {
+                array[i] = array[i + 1];
+            }
+        }
+        return ret;
+    }
+
+    @Override
+    public boolean contains(Integer item) {
+        if (item == null) {
+            throw new IllegalArgumentException();
+        }
+        sort();
+        return containsBinary(item);
+    }
+
+    @Override
+    public int indexOf(Integer item) {
+        if (item == null) {
+            throw new IllegalArgumentException();
+        }
+        for (int i = 0; i < size; i++) {
+            if (array[i] != null && array[i].equals(item)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public int lastIndexOf(Integer item) {
+        if (item == null) {
+            throw new IllegalArgumentException();
+        }
+        for (int i = size - 1; i >= 0; i--) {
+            if (array[i] != null && array[i].equals(item)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public Integer get(int index) {
+        if (index >= size || index < 0) {
+            throw new IndexOutOfBoundsException();
+        }
+        return array[index];
+    }
+
+    @Override
+    public boolean equals(IntegerList otherList) {
+        if (otherList == null) {
+            throw new IllegalArgumentException();
+        }
+        if (size() == otherList.size()) {
+            for (int i = 0; i <= size() - 1; i++) {
+                if (!array[i].equals(otherList.get(i))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public int size() {
+        int i = size - 1;
+        while (i >= 0) {
+            if (array[i] != null) {
+                return i + 1;
+            }
+            i--;
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        int i = 0;
+        while (i < size) {
+            if (array[i] != null) {
+                return false;
+            }
+            i++;
+        }
+        return true;
+    }
+
+    @Override
+    public void clear() {
+        Arrays.fill(array, null);
+    }
+
+    @Override
+    public Integer[] toArray() {
+        Integer[] newArr = new Integer[size()];
+        for (int i = 0; i <= size() - 1; i++) {
+            newArr[i] = array[i];
+        }
+        return newArr;
+    }
+
+    public void sort() {
+        for (int i = 1; i < size(); i++) {
+            Integer temp = array[i];
+            int j = i;
+            while (j > 0 && array[j - 1] >= temp) {
+                array[j] = array[j - 1];
+                j--;
+            }
+            array[j] = temp;
+        }
+    }
+
+    private boolean containsBinary(int element) {
+        int min = 0;
+        int max = size() - 1;
+
+        while (min <= max) {
+            int mid = (min + max) / 2;
+
+            if (element == array[mid]) {
+                return true;
+            }
+
+            if (element < array[mid]) {
+                max = mid - 1;
+            } else {
+                min = mid + 1;
+            }
+        }
+        return false;
+    }
+
+}
diff --git a/src/test/java/org/example/IntegerListImplTest.java b/src/test/java/org/example/IntegerListImplTest.java
new file mode 100644
index 0000000..97a08ea
--- /dev/null
+++ b/src/test/java/org/example/IntegerListImplTest.java
@@ -0,0 +1,182 @@
+package org.example;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class IntegerListImplTest {
+
+    IntegerList IntegerList1 = new IntegerListImpl(5);
+    IntegerList IntegerList2 = new IntegerListImpl(0);
+
+    @BeforeEach
+    void init() {
+        IntegerList1.add(12);
+        IntegerList1.add(24);
+        IntegerList1.add(36);
+    }
+
+    @Test
+    void add() {
+        Integer expected = IntegerList1.add(32);
+        Integer actual = IntegerList1.get(3);
+        assertEquals(expected, actual);
+        assertThrows(IllegalArgumentException.class, () -> IntegerList1.add(null));
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> IntegerList2.add(null));
+    }
+
+    @Test
+    void testAdd() {
+        Integer expected = IntegerList1.add(2, 32);
+        Integer actual = IntegerList1.get(2);
+        assertEquals(expected, actual);
+        expected = 36;
+        actual = IntegerList1.get(3);
+        assertEquals(expected, actual);
+        assertThrows(IllegalArgumentException.class, () -> IntegerList1.add(2, null));
+        IntegerList1.add(34);
+        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.add(10, 8));
+        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.add(-1, 8));
+        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.add(1, 8));
+    }
+
+    @Test
+    void set() {
+        Integer expected = IntegerList1.set(2, 65);
+        Integer actual = IntegerList1.get(2);
+        assertEquals(expected, actual);
+        assertThrows(IllegalArgumentException.class, () -> IntegerList1.add(2, null));
+        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.add(10, 8));
+    }
+
+    @Test
+    void remove() {
+        Integer expected = IntegerList1.remove((Integer) 36);
+        Integer actual = 36;
+        assertEquals(expected, actual);
+        assertThrows(IllegalArgumentException.class, () -> IntegerList1.remove((Integer) 36));
+    }
+
+    @Test
+    void testRemove() {
+        Integer expected = IntegerList1.remove(2);
+        Integer actual = 36;
+        assertEquals(expected, actual);
+        assertThrows(IllegalArgumentException.class, () -> IntegerList1.remove(2));
+        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList2.remove(0));
+    }
+
+    @Test
+    void contains() {
+        var expected = IntegerList1.contains(36);
+        var actual = true;
+        assertEquals(expected, actual);
+        expected = IntegerList1.contains(88);
+        actual = false;
+        assertEquals(expected, actual);
+        assertThrows(IllegalArgumentException.class, () -> IntegerList1.contains(null));
+    }
+
+    @Test
+    void indexOf() {
+        var expected = IntegerList1.indexOf(36);
+        var actual = 2;
+        assertEquals(expected, actual);
+        expected = IntegerList1.indexOf(88);
+        actual = -1;
+        assertEquals(expected, actual);
+        assertThrows(IllegalArgumentException.class, () -> IntegerList1.indexOf(null));
+    }
+
+    @Test
+    void lastIndexOf() {
+        var expected = IntegerList1.lastIndexOf(36);
+        var actual = 2;
+        assertEquals(expected, actual);
+        expected = IntegerList1.lastIndexOf(88);
+        actual = -1;
+        assertEquals(expected, actual);
+        assertThrows(IllegalArgumentException.class, () -> IntegerList1.lastIndexOf(null));
+    }
+
+    @Test
+    void get() {
+        var expected = IntegerList1.get(2);
+        var actual = 36;
+        assertEquals(expected, actual);
+        assertThrows(IndexOutOfBoundsException.class, () -> IntegerList1.get(-1));
+    }
+
+    @Test
+    void testEquals() {
+        IntegerList IntegerList3 = new IntegerListImpl(5);
+        IntegerList3.add(12);
+        IntegerList3.add(24);
+        IntegerList3.add(36);
+        var expected = true;
+        var actual = IntegerList1.equals(IntegerList3);
+        assertEquals(expected, actual);
+        expected = false;
+        actual = IntegerList1.equals(IntegerList2);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void size() {
+        var expected = 3;
+        var actual = IntegerList1.size();
+        assertEquals(expected, actual);
+        expected = 0;
+        actual = IntegerList2.size();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void isEmpty() {
+        var expected = true;
+        var actual = IntegerList2.isEmpty();
+        assertEquals(expected, actual);
+        expected = false;
+        actual = IntegerList1.isEmpty();
+        assertEquals(expected, actual);
+        expected = true;
+        IntegerList IntegerList3 = new IntegerListImpl(5);
+        actual = IntegerList3.isEmpty();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void clear() {
+        IntegerList1.clear();
+        var expected = true;
+        var actual = IntegerList1.isEmpty();
+        assertEquals(expected, actual);
+        IntegerList2.clear();
+        expected = true;
+        actual = IntegerList2.isEmpty();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void toArray() {
+        Integer[] expected = {12, 24, 36};
+        Integer[] actual = IntegerList1.toArray();
+        assertIterableEquals(Arrays.asList(expected), Arrays.asList(actual));
+    }
+
+    @Test
+    void sortInsertion() {
+        IntegerList IntegerList3 = new IntegerListImpl(5);
+        IntegerList3.add(36);
+        IntegerList3.add(24);
+        IntegerList3.add(12);
+        IntegerList3.sort();
+        Integer[] expected = {12, 24, 36};
+        Integer[] actual = IntegerList3.toArray();
+        assertIterableEquals(Arrays.asList(expected), Arrays.asList(actual));
+
+    }
+}
\ No newline at end of file