Int Array

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);
     }
 }

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();
+}

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;
+    }
+
+}