From 72c8dc186598ba0e5f5af2cb2c11c33afbc995dc Mon Sep 17 00:00:00 2001 From: Frolov Georgy Date: Wed, 10 Nov 2021 22:02:58 +0300 Subject: [PATCH] Created custom ArrayList --- .gitignore | 1 + src/Frolov/CheckGarriksList.java | 255 ++++++++++++++++++ src/Frolov/GarriksArrayList.java | 226 ++++++++++++++++ src/Frolov/GarriksIterator.java | 28 ++ src/Frolov/GarriksListIterator.java | 74 +++++ ...5\321\202\320\276\320\264\320\276\320\262" | 21 ++ 6 files changed, 605 insertions(+) create mode 100644 src/Frolov/CheckGarriksList.java create mode 100644 src/Frolov/GarriksArrayList.java create mode 100644 src/Frolov/GarriksIterator.java create mode 100644 src/Frolov/GarriksListIterator.java create mode 100644 "\321\201\321\200\320\260\320\262\320\275\320\265\320\275\320\270\320\265 \320\262\321\200\320\265\320\274\320\265\320\275\320\270 \320\274\320\265\321\202\320\276\320\264\320\276\320\262" diff --git a/.gitignore b/.gitignore index a1c2a23..1bc94f3 100644 --- a/.gitignore +++ b/.gitignore @@ -21,3 +21,4 @@ # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* +/.idea/ diff --git a/src/Frolov/CheckGarriksList.java b/src/Frolov/CheckGarriksList.java new file mode 100644 index 0000000..0fff458 --- /dev/null +++ b/src/Frolov/CheckGarriksList.java @@ -0,0 +1,255 @@ +package Frolov; + +import java.util.ArrayList; +import java.util.List; + +public class CheckGarriksList { + + private static void endTime(double start, String funcName) { + System.out.printf("%-20s %-30s %.0f %s", "Время работы", funcName, (System.currentTimeMillis() - start), "мс\n\n"); + } + + public static void main(String[] args) { + List garriksList = new GarriksArrayList(); + List originalList = new ArrayList(); + + + double start = System.currentTimeMillis(); + for (int i = 0; i < 50000; i++) { + garriksList.add(i); + } + endTime(start, "garriksList.add "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 50000; i++) { + originalList.add(i); + } + endTime(start, "originalList.add "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 50000; i++) { + garriksList.size(); + } + endTime(start, "garriksList.size "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 50000; i++) { + originalList.size(); + } + endTime(start, "originalList.size "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 50000; i++) { + garriksList.isEmpty(); + } + endTime(start, "garriksList.isEmpty "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 50000; i++) { + originalList.isEmpty(); + } + endTime(start, "originalList.isEmpty "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 1000; i++) { + garriksList.contains(49998); + } + endTime(start, "garriksList.contains "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 1000; i++) { + originalList.contains(49998); + } + endTime(start, "originalList.contains "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 1000; i++) { + garriksList.toArray(); + } + endTime(start, "garriksList.toArray "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 1000; i++) { + originalList.toArray(); + } + endTime(start, "originalList.toArray "); + + + List newGarriksList = garriksList.subList(0, 49999); + List newOriginalList = new ArrayList(originalList); + start = System.currentTimeMillis(); + for (int i = 0; i < 49998; i++) { + newGarriksList.remove(newGarriksList.size() - 1); + } + endTime(start, "garriksList.remove "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 49998; i++) { + newOriginalList.remove(newOriginalList.size() - 1); + } + endTime(start, "originalList.remove "); + + + newGarriksList = garriksList.subList(0, 49999); + newOriginalList = new ArrayList(originalList); + start = System.currentTimeMillis(); + for (int i = 0; i < 49998; i++) { + newGarriksList.clear(); + } + endTime(start, "garriksList.clear "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 49998; i++) { + newOriginalList.clear(); + } + endTime(start, "originalList.clear "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + garriksList.get(i); + } + endTime(start, "garriksList.get "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + originalList.get(i); + } + endTime(start, "originalList.get "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + garriksList.set(i, i); + } + endTime(start, "garriksList.set "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + originalList.set(i, i); + } + endTime(start, "originalList.set "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + garriksList.add(i, i); + } + endTime(start, "garriksList.add "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + originalList.add(i, i); + } + endTime(start, "originalList.add "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + garriksList.indexOf(i); + } + endTime(start, "garriksList.indexOf "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + originalList.indexOf(i); + } + endTime(start, "originalList.indexOf "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + garriksList.lastIndexOf(i); + } + endTime(start, "garriksList.lastIndexOf "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 49999; i++) { + originalList.lastIndexOf(i); + } + endTime(start, "originalList.lastIndexOf "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 48999; i++) { + garriksList.subList(i, i + 100); + } + endTime(start, "garriksList.subList "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 48999; i++) { + originalList.subList(i, i + 100); + } + endTime(start, "originalList.subList "); + + + newGarriksList = garriksList.subList(0, 4999); + newOriginalList = new ArrayList(originalList); + start = System.currentTimeMillis(); + for (int i = 0; i < 10; i++) { + newGarriksList.retainAll(newOriginalList); + } + endTime(start, "garriksList.retainAll "); + + newGarriksList = garriksList.subList(0, 4999); + newOriginalList = new ArrayList(originalList); + start = System.currentTimeMillis(); + for (int i = 0; i < 10; i++) { + newOriginalList.retainAll(newGarriksList); + } + endTime(start, "originalList.retainAll "); + + + newGarriksList = garriksList.subList(0, 4999); + newOriginalList = new ArrayList(originalList); + start = System.currentTimeMillis(); + for (int i = 0; i < 10; i++) { + newGarriksList.removeAll(newOriginalList); + } + endTime(start, "garriksList.removeAll "); + + newGarriksList = garriksList.subList(0, 4999); + newOriginalList = new ArrayList(originalList); + start = System.currentTimeMillis(); + for (int i = 0; i < 10; i++) { + newOriginalList.removeAll(newGarriksList); + } + endTime(start, "originalList.removeAll "); + + + newGarriksList = garriksList.subList(0, 4999); + newOriginalList = new ArrayList(originalList); + start = System.currentTimeMillis(); + for (int i = 0; i < 10; i++) { + newGarriksList.containsAll(newOriginalList); + } + endTime(start, "garriksList.containsAll "); + + newGarriksList = garriksList.subList(0, 4999); + newOriginalList = new ArrayList(originalList); + start = System.currentTimeMillis(); + for (int i = 0; i < 10; i++) { + newOriginalList.containsAll(newGarriksList); + } + endTime(start, "originalList.containsAll "); + + + start = System.currentTimeMillis(); + for (int i = 0; i < 100; i++) { + garriksList.toString(); + } + endTime(start, "garriksList.toString "); + + start = System.currentTimeMillis(); + for (int i = 0; i < 100; i++) { + originalList.toString(); + } + endTime(start, "originalList.toString "); + + + } +} diff --git a/src/Frolov/GarriksArrayList.java b/src/Frolov/GarriksArrayList.java new file mode 100644 index 0000000..b523f9f --- /dev/null +++ b/src/Frolov/GarriksArrayList.java @@ -0,0 +1,226 @@ +package Frolov; + +import java.util.*; + +public class GarriksArrayList implements List { + private Object[] realArr; + private int elemsCount; + + public GarriksArrayList() { + this.elemsCount = 0; + this.realArr = new Object[10]; + } + + public GarriksArrayList(int elemsCount, Object[] realArr) { + this.elemsCount = elemsCount; + this.realArr = realArr; + } + + @Override + public int size() { + return elemsCount; + } + + @Override + public boolean isEmpty() { + return elemsCount <= 0; + } + + // тут лучше использовать == или equals? Я понимаю, что equals вернет true в отличии от ==, если экзмепляры разные, но все поля одинаковые. + @Override + public boolean contains(Object o) { + int i = 0; + while (i < elemsCount) { + if (o.equals(realArr[i++])) { + return true; + } + } + return false; + } + + @Override + public Iterator iterator() { + return new GarriksIterator(this); + } + + @Override + public Object[] toArray() { + Object[] arr = new Object[size()]; + for (int i = 0; i < size(); i++) { + arr[i] = get(i); + } + return arr.clone(); + } + + @Override + public boolean add(Object o) { + guaranteedLength(realArr.length + 1); + realArr[elemsCount++] = o; + return true; + } + + @Override + public boolean remove(Object o) { + for (int i = 0; i < elemsCount; i++) { + if (realArr[i] == o) { + Object[] tempArr = new Object[realArr.length]; + System.arraycopy(realArr, 0, tempArr, 0, i); + System.arraycopy(realArr, i + 1, tempArr, i, elemsCount - i - 1); + realArr = tempArr; + return true; + } + } + return false; + } + + @Override + public boolean addAll(Collection collection) { + //сложна, как можно объеденить две коллекции в одну и потом привести к array + return false; + } + + @Override + public boolean addAll(int i, Collection collection) { + //сложна, как можно объеденить две коллекции в одну и потом привести к array + return false; + } + + @Override + public void clear() { + // допускается ли так писать? + realArr = new Object[]{null, null, null, null, null, null, null, null, null, null}; + elemsCount = 0; + } + + @Override + public Object get(int i) { + return realArr[i]; + } + + @Override + public Object set(int i, Object o) { + realArr[i] = o; + return o; + } + + @Override + public void add(int i, Object o) { + guaranteedLength(realArr.length + 1); + Object[] tempArr = new Object[realArr.length]; + System.arraycopy(realArr, 0, tempArr, 0, i); + tempArr[i] = o; + System.arraycopy(realArr, i, tempArr, i + 1, elemsCount - i); + realArr = tempArr; + } + + @Override + public Object remove(int i) { + Object result = realArr[i]; + Object[] tempArr = new Object[realArr.length]; + System.arraycopy(realArr, 0, tempArr, 0, i); + System.arraycopy(realArr, i + 1, tempArr, i, --elemsCount - i); + realArr = tempArr; + guaranteedLength(realArr.length); + return result; + } + + @Override + public int indexOf(Object o) { + for (int i = 0; i < elemsCount; i++) { + if (realArr[i] == o) { + return i; + } + } + // в питоновском аналогичном методе, если объект не найден, то возвращается -1, как принято в java? + return -1; + } + + @Override + public int lastIndexOf(Object o) { + for (int i = elemsCount - 1; i >= 0; i--) { + if (realArr[i] == o) { + return i; + } + } + return -1; + } + + @Override + public ListIterator listIterator() { + return new GarriksListIterator(this); + } + + // я же правильно понял, что этот метод возвращает итератор, начиная от указанного индекса i? + @Override + public ListIterator listIterator(int i) { + return new GarriksListIterator(this, i); + } + + @Override + public List subList(int i, int i1) { + List resultList = new GarriksArrayList(); + for (int j = i; j < i1; j++) { + resultList.add(realArr[j]); + } + return resultList; + } + + @Override + public boolean retainAll(Collection collection) { + boolean result = false; + for (Object elem : collection) { + if (!this.contains(elem)) { + this.remove(elem); + result = true; + } + } + return result; + } + + @Override + public boolean removeAll(Collection collection) { + boolean result = false; + for (Object elem : collection) { + if (this.contains(elem)) { + this.remove(elem); + result = true; + } + } + return result; + } + + @Override + public boolean containsAll(Collection collection) { + for (Object elem : collection) { + if (!this.contains(elem)) { + return false; + } + } + return true; + } + + // + @Override + public Object[] toArray(Object[] objects) { + return new Object[0]; + } + + @Override + public String toString() { + return Arrays.toString(realArr); + } + + private void guaranteedLength(int newLength) { + if (elemsCount + 1 >= newLength) { + Object[] tempArr = new Object[(realArr.length * 3 / 2) + 1]; + System.arraycopy(realArr, 0, tempArr, 0, realArr.length); + realArr = tempArr; + return; + } + if (realArr.length > 10 && newLength > elemsCount * 3 / 2 + 1) { + Object[] tempArr = new Object[Math.max(elemsCount, 10)]; + System.arraycopy(realArr, 0, tempArr, 0, Math.max(elemsCount, 10)); + realArr = tempArr; + } + } +} diff --git a/src/Frolov/GarriksIterator.java b/src/Frolov/GarriksIterator.java new file mode 100644 index 0000000..e2c9d4d --- /dev/null +++ b/src/Frolov/GarriksIterator.java @@ -0,0 +1,28 @@ +package Frolov; + +import java.util.Iterator; +import java.util.NoSuchElementException; + +public class GarriksIterator implements Iterator { + + private final GarriksArrayList arr; + private int currElemIndex; + + public GarriksIterator(GarriksArrayList arr) { + this.arr = arr; + this.currElemIndex = -1; + } + + @Override + public boolean hasNext() { + return (currElemIndex + 1 <= arr.size()); + } + + @Override + public Object next() { + if (!this.hasNext()) { + throw new NoSuchElementException("Garriks iterator can't see more elements :)"); + } + return arr.get(++currElemIndex); + } +} diff --git a/src/Frolov/GarriksListIterator.java b/src/Frolov/GarriksListIterator.java new file mode 100644 index 0000000..dec8f7a --- /dev/null +++ b/src/Frolov/GarriksListIterator.java @@ -0,0 +1,74 @@ +package Frolov; + +import java.util.ListIterator; +import java.util.NoSuchElementException; + +public class GarriksListIterator implements ListIterator { + + private final GarriksArrayList arr; + private final int startElemIndex; + private int currElemIndex; + + public GarriksListIterator(GarriksArrayList arr, int i) { + this.arr = arr; + this.startElemIndex = i; + this.currElemIndex = i; + } + + public GarriksListIterator(GarriksArrayList arr) { + this.arr = arr; + this.startElemIndex = 0; + this.currElemIndex = -1; + } + + @Override + public boolean hasNext() { + return (currElemIndex + 1 <= arr.size()); + } + + @Override + public Object next() { + if (!this.hasNext()) { + throw new NoSuchElementException("Garriks list iterator can't see more elements :)"); + } + return arr.get(++currElemIndex); + } + + @Override + public boolean hasPrevious() { + return (currElemIndex - 1 >= startElemIndex); + } + + @Override + public Object previous() { + if (!this.hasPrevious()) { + throw new NoSuchElementException("Garriks list iterator can't see more elements :)"); + } + return arr.get(--currElemIndex); + } + + @Override + public int nextIndex() { + return this.hasNext() ? currElemIndex + 1 : -1; + } + + @Override + public int previousIndex() { + return this.hasPrevious() ? currElemIndex - 1 : -1; + } + + @Override + public void remove() { + arr.remove(currElemIndex); + } + + @Override + public void set(Object o) { + arr.set(currElemIndex, o); + } + + @Override + public void add(Object o) { + arr.add(currElemIndex + 1, o); + } +} diff --git "a/\321\201\321\200\320\260\320\262\320\275\320\265\320\275\320\270\320\265 \320\262\321\200\320\265\320\274\320\265\320\275\320\270 \320\274\320\265\321\202\320\276\320\264\320\276\320\262" "b/\321\201\321\200\320\260\320\262\320\275\320\265\320\275\320\270\320\265 \320\262\321\200\320\265\320\274\320\265\320\275\320\270 \320\274\320\265\321\202\320\276\320\264\320\276\320\262" new file mode 100644 index 0000000..756cdcf --- /dev/null +++ "b/\321\201\321\200\320\260\320\262\320\275\320\265\320\275\320\270\320\265 \320\262\321\200\320\265\320\274\320\265\320\275\320\270 \320\274\320\265\321\202\320\276\320\264\320\276\320\262" @@ -0,0 +1,21 @@ +метод время кастомного, мс время оригинала, мс +add(int i) 4 4 +size() 3 2 +isEmpty() 3 3 +contains(Obj o) 47 47 +toArray() 248 37 +remove(int i) 1447 2 +clear() 2 2 +get() 0 1 +set(int i, Obj o) 2 2 +add(int i, Obj o) 1555 475 +indexOf(Obj o) 751 919 +lastIndexOf(Obj o) 753 1048 +subList(int i, int i1) 49 6 +retainAll(Coll coll) 4609 485 +removeAll(Coll coll) 4516 3161 +containsAll(Coll coll) 122 124 +toString() 191 344 + +Методы повторялись некоторое количество раз, количество повторений зависело от времени одного раза. +