Yatopia/patches/server/0020-Add-GlueList.patch

1066 lines
27 KiB
Diff
Raw Normal View History

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Mykyta Komarn <nkomarn@hotmail.com>
Date: Wed, 30 Sep 2020 18:03:27 -0700
Subject: [PATCH] Add GlueList
This is the fastest List implementation I could find out there.
diff --git a/src/main/java/net/yatopia/server/list/GlueList.java b/src/main/java/net/yatopia/server/list/GlueList.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa3064985f9d9b29660fec40c5532b02a898aa04
--- /dev/null
+++ b/src/main/java/net/yatopia/server/list/GlueList.java
@@ -0,0 +1,1051 @@
+package net.yatopia.server.list;
+
+/**
+ * Copyright 2015 Ertuğrul Çetin
+ * <p/>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p/>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p/>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+
+import static java.lang.Math.abs;
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+
+
+/**
+ * GlueList is a brand new List implementation which is way faster than ArrayList and LinkedList.
+ * This implementation inspired from ArrayList and LinkedList working mechanism.
+ * <br>
+ * Nodes holding data in arrays, in the beginning the world just like ArrayList ,inserts data into array one by one when there is no space for insertion to array
+ * new Node will be created and linked with the last Node.
+ * <br>
+ * The array which belongs to newly created node has half of the size of list , just like ArrayList.
+ * In ArrayList when there is no space for it it creates new array with double of old size and inserts old data into new one.
+ * Unlike ArrayList GlueList does it dynamically way with creating new node so old data does NOT have to be moved to another array.
+ * You can think that GlueList is dynamic version of ArrayList.
+ * <br>
+ * Adding and removing operations much faster than ArrayList and LinkedList.
+ * Searching operations nearly same with ArrayList and way better than LinkedList.
+ * <p/>
+ * Best Case<br>
+ * Add O(1)<br>
+ * Remove O(1)<br>
+ * Search O(1)<br>
+ * Access O(1)
+ * <br><br>
+ * "m" number of created nodes.<br>
+ * "n" size of node array.<br>
+ * If you insert 10_000_000 record into List there will be just 36 nodes.<br><br>
+ * Worst Case<br>
+ * Add O(n*m)<br>
+ * Remove O(n*m)<br>
+ * Search O(m)<br>
+ * Access O(m)
+ * <p/>
+ * version v1.0
+ * <p/>
+ * Date: 03.11.2015
+ * <p/>
+ *
+ * @author Ertuğrul Çetin ~ ertu.ctn@gmail.com
+ * @see Collection
+ * @see List
+ * @see LinkedList
+ * @see ArrayList
+ * @param <T> the type of elements held in this collection
+ */
+public class GlueList<T> extends AbstractList<T> implements List<T>, Cloneable, Serializable {
+
+ transient Node<T> first;
+ transient Node<T> last;
+
+ int size;
+
+ int initialCapacity;
+
+ private static final int DEFAULT_CAPACITY = 10;
+
+ private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+
+ public GlueList() {
+
+ Node<T> initNode = new Node<>(null, null, 0, DEFAULT_CAPACITY);
+
+ first = initNode;
+ last = initNode;
+ }
+
+ public GlueList(int initialCapacity) {
+
+ this.initialCapacity = (initialCapacity > MAX_ARRAY_SIZE) ? MAX_ARRAY_SIZE : initialCapacity;
+
+ Node<T> initNode = new Node<>(null, null, 0, initialCapacity);
+
+ first = initNode;
+ last = initNode;
+ }
+
+ public GlueList(Collection<? extends T> c) {
+
+ Objects.requireNonNull(c);
+
+ Object[] arr = c.toArray();
+
+ int len = arr.length;
+
+ if (len != 0) {
+
+ Node<T> initNode = new Node<>(null, null, 0, len);
+
+ first = initNode;
+ last = initNode;
+
+ System.arraycopy(arr, 0, last.elementData, 0, len);
+
+ last.elementDataPointer += len;
+ } else {
+
+ Node<T> initNode = new Node<>(null, null, 0, DEFAULT_CAPACITY);
+
+ first = initNode;
+ last = initNode;
+ }
+
+ modCount++;
+ size += len;
+ }
+
+ @Override
+ public boolean add(T element) {
+
+ Node<T> l = last;
+
+ if (l.isAddable()) {
+ l.add(element);
+ } else {
+ Node<T> newNode = new Node<>(l, null, size);
+ newNode.add(element);
+ last = newNode;
+ l.next = last;
+ }
+
+ modCount++;
+ size++;
+
+ return true;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public void add(int index, T element) {
+
+ rangeCheckForAdd(index);
+
+ Node<T> node = getNodeForAdd(index);
+
+ if (node == null) {
+
+ Node<T> l = last;
+
+ Node<T> newNode = new Node<>(l, null, size);
+
+ last = newNode;
+
+ l.next = last;
+
+ node = newNode;
+ }
+
+ //if it is last and has extra space for element...
+ if (node == last && node.elementData.length - node.elementDataPointer > 0) {
+
+ int nodeArrIndex = index - node.startingIndex;
+
+ System.arraycopy(node.elementData, nodeArrIndex, node.elementData, nodeArrIndex + 1, node.elementDataPointer - nodeArrIndex);
+
+ node.elementData[nodeArrIndex] = element;
+
+ if (nodeArrIndex > 0) {
+ System.arraycopy(node.elementData, 0, node.elementData, 0, nodeArrIndex);
+ }
+
+ node.elementDataPointer++;
+ } else {
+
+ int newLen = node.elementData.length + 1;
+ T[] newElementData = (T[]) new Object[newLen];
+
+ int nodeArrIndex = index - node.startingIndex;
+
+ System.arraycopy(node.elementData, nodeArrIndex, newElementData, nodeArrIndex + 1, node.elementDataPointer - nodeArrIndex);
+
+ newElementData[nodeArrIndex] = element;
+
+ if (nodeArrIndex > 0) {
+ System.arraycopy(node.elementData, 0, newElementData, 0, nodeArrIndex);
+ }
+
+ node.elementData = newElementData;
+ node.endingIndex++;
+ node.elementDataPointer++;
+ }
+
+ updateNodesAfterAdd(node);
+
+ modCount++;
+ size++;
+ }
+
+ private void rangeCheckForAdd(int index) {
+
+ if (index > size || index < 0) {
+ throw new ArrayIndexOutOfBoundsException(index);
+ }
+ }
+
+ private void updateNodesAfterAdd(Node<T> nodeFrom) {
+
+ for (Node<T> node = nodeFrom.next; node != null; node = node.next) {
+
+ node.startingIndex++;
+ node.endingIndex++;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public boolean addAll(Collection<? extends T> c) {
+
+ Objects.requireNonNull(c);
+
+ Object[] collection = c.toArray();
+
+ int len = collection.length;
+
+ if (len == 0) {
+ return false;
+ }
+
+ if (size == 0) {
+
+ if (initialCapacity >= len) {
+ System.arraycopy(collection, 0, last.elementData, 0, len);
+ } else {
+ last.elementData = Arrays.copyOf((T[]) collection, len);
+ last.endingIndex = len - 1;
+ }
+
+ last.elementDataPointer += len;
+
+ modCount++;
+ size += len;
+
+ return true;
+ }
+
+ int elementDataLen = last.elementData.length;
+ int elementSize = last.elementDataPointer;
+
+ int remainedStorage = elementDataLen - elementSize;
+
+ if (remainedStorage == 0) {
+
+ Node<T> l = last;
+
+ int newLen = (size >>> 1);
+ int initialLen = (len > newLen) ? len : newLen;
+
+ Node<T> newNode = new Node<>(l, null, size, initialLen);
+
+ System.arraycopy(collection, 0, newNode.elementData, 0, len);
+
+ newNode.elementDataPointer += len;
+
+ last = newNode;
+ l.next = last;
+
+ modCount++;
+ size += len;
+
+ return true;
+ }
+
+ if (len <= remainedStorage) {
+
+ System.arraycopy(collection, 0, last.elementData, elementSize, len);
+
+ last.elementDataPointer += len;
+
+ modCount++;
+ size += len;
+
+ return true;
+ }
+
+ if (len > remainedStorage) {
+
+ System.arraycopy(collection, 0, last.elementData, elementSize, remainedStorage);
+
+ last.elementDataPointer += remainedStorage;
+ size += remainedStorage;
+
+ int newLen = (size >>> 1);
+ int remainedDataLen = len - remainedStorage;
+
+ int initialLen = (newLen > remainedDataLen) ? newLen : remainedDataLen;
+
+ Node<T> l = last;
+
+ Node<T> newNode = new Node<>(l, null, size, initialLen);
+
+ System.arraycopy(collection, remainedStorage, newNode.elementData, 0, remainedDataLen);
+
+ newNode.elementDataPointer += remainedDataLen;
+
+ last = newNode;
+ l.next = last;
+
+ modCount++;
+ size += remainedDataLen;
+
+ return true;
+ }
+
+ return false;
+ }
+
+ @Override
+ public T set(int index, T element) {
+
+ rangeCheck(index);
+
+ Node<T> node = getNode(index);
+
+ int nodeArrIndex = index - node.startingIndex;
+
+ T oldValue = node.elementData[nodeArrIndex];
+
+ node.elementData[nodeArrIndex] = element;
+
+ return oldValue;
+ }
+
+ @Override
+ public T get(int index) {
+
+ rangeCheck(index);
+
+ Node<T> node = getNode(index);
+
+ return node.elementData[index - node.startingIndex];
+ }
+
+ @Override
+ public int indexOf(Object o) {
+
+ int index = 0;
+
+ if (o == null) {
+
+ for (Node<T> node = first; node != null; node = node.next) {
+ for (int i = 0; i < node.elementDataPointer; i++) {
+ if (node.elementData[i] == null) {
+ return index;
+ }
+ index++;
+ }
+ }
+ } else {
+
+ for (Node<T> node = first; node != null; node = node.next) {
+ for (int i = 0; i < node.elementDataPointer; i++) {
+ if (o.equals(node.elementData[i])) {
+ return index;
+ }
+ index++;
+ }
+ }
+ }
+
+ return -1;
+ }
+
+ @Override
+ public int lastIndexOf(Object o) {
+
+ int index = size - 1;
+
+ if (o == null) {
+ for (Node<T> node = last; node != null; node = node.pre) {
+ for (int i = node.elementDataPointer - 1; i >= 0; i--) {
+ if (node.elementData[i] == null) {
+ return index;
+ }
+ index--;
+ }
+ }
+ } else {
+
+ for (Node<T> node = last; node != null; node = node.pre) {
+ for (int i = node.elementDataPointer - 1; i >= 0; i--) {
+ if (o.equals(node.elementData[i])) {
+ return index;
+ }
+ index--;
+ }
+ }
+ }
+
+ return -1;
+ }
+
+ @Override
+ public boolean contains(Object o) {
+ return indexOf(o) != -1;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public T remove(int index) {
+
+ rangeCheck(index);
+
+ Node<T> node;
+
+ if (size == 2 && first != last) {
+
+ Node<T> newNode = new Node<>(null, null, 0, 2);
+ newNode.add(first.elementData[0]);
+ newNode.add(last.elementData[0]);
+
+ node = first = last = newNode;
+ } else {
+ node = getNode(index);
+ }
+
+ T[] elementData = node.elementData;
+
+ int elementSize = node.elementDataPointer;
+
+ int nodeArrIndex = index - node.startingIndex;
+
+ T oldValue = elementData[nodeArrIndex];
+
+ int numMoved = elementSize - nodeArrIndex - 1;
+
+ if (numMoved > 0) {
+ System.arraycopy(node.elementData, nodeArrIndex + 1, node.elementData, nodeArrIndex, numMoved);
+ }
+
+ if (first == last || node == last) {
+ node.elementData[elementSize - 1] = null;
+ } else {
+ node.elementData = Arrays.copyOf(node.elementData, elementSize - 1);
+ node.endingIndex = (--node.endingIndex < 0) ? 0 : node.endingIndex;
+ }
+
+ node.elementDataPointer--;
+
+ updateNodesAfterRemove(node);
+
+ if (node.elementDataPointer == 0 && first != last) {
+
+ Node<T> next = node.next;
+ Node<T> prev = node.pre;
+
+ if (prev == null) {
+ first = next;
+ } else {
+ prev.next = next;
+ node.pre = null;
+ }
+
+ if (next == null) {
+ last = prev;
+ } else {
+ next.pre = prev;
+ node.next = null;
+ }
+
+ node.elementData = null;
+ }
+
+ size--;
+ modCount++;
+
+ return oldValue;
+ }
+
+ @Override
+ public boolean removeAll(Collection<?> c) {
+
+ Objects.requireNonNull(c);
+
+ Object[] arr = c.toArray();
+ if (arr.length == 0) {
+ return false;
+ }
+
+ boolean isModified = false;
+
+ for (Object o : arr) {
+ isModified |= remove(o);
+ }
+
+ return isModified;
+ }
+
+ @Override
+ public boolean retainAll(Collection<?> c) {
+
+ Objects.requireNonNull(c);
+
+ Object[] arr = c.toArray();
+ if (arr.length == 0) {
+ return false;
+ }
+
+ boolean isModified = false;
+
+ Object[] elements = toArray();
+
+ for (Object element : elements) {
+
+ if (!c.contains(element)) {
+ isModified |= remove(element);
+ }
+ }
+
+ return isModified;
+ }
+
+ @Override
+ public boolean remove(Object o) {
+
+ int index = indexOf(o);
+
+ if (index != -1) {
+ remove(index);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private void updateNodesAfterRemove(Node<T> fromNode) {
+
+ for (Node<T> node = fromNode.next; node != null; node = node.next) {
+
+ node.startingIndex = (--node.startingIndex < 0) ? 0 : node.startingIndex;
+ node.endingIndex = (--node.endingIndex < 0) ? 0 : node.endingIndex;
+ }
+ }
+
+ private Node<T> getNode(int index) {
+
+ int firstStartingIndex = first.startingIndex;
+ int firstEndingIndex = first.endingIndex;
+
+ int firstMinDistance = min(abs(index - firstStartingIndex), abs(index - firstEndingIndex));
+
+ int lastStartingIndex = last.startingIndex;
+ int lastEndingIndex = last.endingIndex;
+
+ int lastMinDistance = min(abs(index - lastStartingIndex), abs(index - lastEndingIndex));
+
+ if (firstMinDistance <= lastMinDistance) {
+
+ Node<T> node = first;
+ do {
+
+ if (node.startingIndex <= index && index <= node.endingIndex) {
+ return node;
+ }
+
+ node = node.next;
+ } while (true);
+ } else {
+
+ Node<T> node = last;
+ do {
+
+ if (node.startingIndex <= index && index <= node.endingIndex) {
+ return node;
+ }
+
+ node = node.pre;
+ } while (true);
+ }
+ }
+
+ private Node<T> getNodeForAdd(int index) {
+
+ if (index == size && !(last.startingIndex <= index && index <= last.endingIndex)) {
+ return null;
+ }
+
+ return getNode(index);
+ }
+
+ private void rangeCheck(int index) {
+
+ if (index >= size || index < 0) {
+ throw new ArrayIndexOutOfBoundsException(index);
+ }
+ }
+
+ @Override
+ public void clear() {
+
+ for (Node<T> node = first; node != null; ) {
+
+ Node<T> next = node.next;
+
+ node.next = null;
+ node.pre = null;
+ node.elementData = null;
+
+ node = next;
+ }
+
+ first = last = null;
+
+ int capacity = min(MAX_ARRAY_SIZE, max(size, max(initialCapacity, DEFAULT_CAPACITY)));
+
+ Node<T> initNode = new Node<>(null, null, 0, capacity);
+
+ initialCapacity = capacity;
+
+ first = initNode;
+ last = initNode;
+
+ modCount++;
+ size = 0;
+ }
+
+ public void trimToSize() {
+
+ int pointer = last.elementDataPointer;
+ int arrLen = last.elementData.length;
+
+ if (pointer < arrLen && arrLen > 2) {
+
+ if (pointer < 2) {
+ last.elementData = Arrays.copyOf(last.elementData, 2);
+ last.endingIndex -= arrLen - 2;
+ } else {
+ last.elementData = Arrays.copyOf(last.elementData, pointer);
+ last.endingIndex -= arrLen - pointer;
+ }
+ }
+ }
+
+ @Override
+ public List<T> subList(int fromIndex, int toIndex) {
+ return super.subList(fromIndex, toIndex);
+ }
+
+ @Override
+ public Object[] toArray() {
+
+ Object[] objects = new Object[size];
+
+ int i = 0;
+ for (Node<T> node = first; node != null; node = node.next) {
+
+ int len = node.elementDataPointer;
+
+ if (len > 0) {
+ System.arraycopy(node.elementData, 0, objects, i, len);
+ }
+
+ i += len;
+ }
+
+ return objects;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public <T> T[] toArray(T[] a) {
+ return (T[]) Arrays.copyOf(toArray(), size, a.getClass());
+ }
+
+ public boolean isEmpty() {
+ return size == 0;
+ }
+
+ @Override
+ public Iterator<T> iterator() {
+ return new Itr();
+ }
+
+ private class Itr implements Iterator<T> {
+
+ Node<T> node = first;
+
+ int i = 0;//inner-array index
+ int j = 0;//total index -> cursor
+
+ int lastReturn = -1;
+
+ int expectedModCount = modCount;
+ int elementDataPointer = node.elementDataPointer;
+
+ @Override
+ public boolean hasNext() {
+ return j != size;
+ }
+
+ @Override
+ public T next() {
+
+ checkForComodification();
+
+ if (j >= size) {
+ throw new NoSuchElementException();
+ }
+
+ if (j >= last.endingIndex + 1) {
+ throw new ConcurrentModificationException();
+ }
+
+ if (j == 0) {// it's for listIterator.when node becomes null.
+ node = first;
+ elementDataPointer = node.elementDataPointer;
+ i = 0;
+ }
+
+ T val = node.elementData[i++];
+
+ if (i >= elementDataPointer) {
+ node = node.next;
+ i = 0;
+ elementDataPointer = (node != null) ? node.elementDataPointer : 0;
+ }
+
+ lastReturn = j++;
+
+ return val;
+ }
+
+ @Override
+ public void remove() {
+
+ if (lastReturn < 0) {
+ throw new IllegalStateException();
+ }
+
+ checkForComodification();
+
+ try {
+ GlueList.this.remove(lastReturn);
+
+ j = lastReturn;
+
+ lastReturn = -1;
+
+ i = (--i < 0) ? 0 : i;
+
+ elementDataPointer = (node != null) ? node.elementDataPointer : 0;
+
+ expectedModCount = modCount;
+ } catch (IndexOutOfBoundsException e) {
+ throw new ConcurrentModificationException();
+ }
+ }
+
+ void checkForComodification() {
+ if (modCount != expectedModCount) {
+ throw new ConcurrentModificationException();
+ }
+ }
+ }
+
+ @Override
+ public ListIterator<T> listIterator(int index) {
+
+ checkPositionIndex(index);
+
+ return new ListItr(index);
+ }
+
+ private void checkPositionIndex(int index) {
+
+ if (!(index >= 0 && index <= size)) {
+ throw new ArrayIndexOutOfBoundsException(index);
+ }
+ }
+
+ @Override
+ public ListIterator<T> listIterator() {
+ return new ListItr(0);
+ }
+
+ private class ListItr extends Itr implements ListIterator<T> {
+
+ public ListItr(int index) {
+ node = (index == size) ? last : getNode(index);
+ j = index;
+ i = index - node.startingIndex;
+ elementDataPointer = node.elementDataPointer;
+ }
+
+ @Override
+ public boolean hasPrevious() {
+ return j != 0;
+ }
+
+ @Override
+ public T previous() {
+
+ checkForComodification();
+
+ int temp = j - 1;
+
+ if (temp < 0) {
+ throw new NoSuchElementException();
+ }
+
+ if (temp >= last.endingIndex + 1) {
+ throw new ConcurrentModificationException();
+ }
+
+ if (j == size) {
+
+ node = last;
+
+ elementDataPointer = node.elementDataPointer;
+
+ i = elementDataPointer;
+ }
+
+ int index = j - node.startingIndex;
+ if (index == 0) {
+
+ node = node.pre;
+
+ elementDataPointer = node.elementDataPointer;
+
+ i = elementDataPointer;
+ }
+
+ T val = node.elementData[--i];
+
+ if (i < 0) {
+ node = node.pre;
+ i = (node != null) ? node.elementDataPointer : 0;
+ }
+
+ j = temp;
+
+ lastReturn = j;
+
+ return val;
+ }
+
+ @Override
+ public int nextIndex() {
+ return j;
+ }
+
+ @Override
+ public int previousIndex() {
+ return j - 1;
+ }
+
+ @Override
+ public void set(T t) {
+
+ if (lastReturn < 0) {
+ throw new IllegalStateException();
+ }
+
+ checkForComodification();
+
+ try {
+ GlueList.this.set(lastReturn, t);
+ } catch (IndexOutOfBoundsException e) {
+ throw new ConcurrentModificationException();
+ }
+ }
+
+ @Override
+ public void add(T t) {
+
+ checkForComodification();
+
+ try {
+ int temp = j;
+
+ GlueList.this.add(temp, t);
+
+ j = temp + 1;
+
+ lastReturn = -1;
+
+ i++;
+ elementDataPointer = (node != null) ? node.elementDataPointer : 0;
+
+ expectedModCount = modCount;
+ } catch (IndexOutOfBoundsException e) {
+ throw new ConcurrentModificationException();
+ }
+ }
+ }
+
+ @Override
+ public int size() {
+ return size;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public Object clone() {
+
+ try {
+ GlueList<T> clone = (GlueList<T>) super.clone();
+
+ clone.first = clone.last = null;
+
+ int capacity = min(MAX_ARRAY_SIZE, max(clone.size, max(clone.initialCapacity, DEFAULT_CAPACITY)));
+
+ Node<T> initNode = new Node<>(null, null, 0, capacity);
+
+ clone.initialCapacity = capacity;
+
+ clone.first = clone.last = initNode;
+
+ clone.modCount = 0;
+ clone.size = 0;
+
+ for (Node<T> node = first; node != null; node = node.next) {
+
+ for (int i = 0; i < node.elementDataPointer; i++) {
+ clone.add(node.elementData[i]);
+ }
+ }
+
+ return clone;
+ } catch (CloneNotSupportedException e) {
+ throw new InternalError();
+ }
+ }
+
+ private void writeObject(ObjectOutputStream s) throws IOException {
+
+ int expectedModCount = modCount;
+
+ s.defaultWriteObject();
+
+ s.writeInt(size);
+
+ for (Node<T> node = first; node != null; node = node.next) {
+ for (int i = 0; i < node.elementDataPointer; i++) {
+ s.writeObject(node.elementData[i]);
+ }
+ }
+
+ if (modCount != expectedModCount) {
+ throw new ConcurrentModificationException();
+ }
+ }
+
+
+ @SuppressWarnings("unchecked")
+ private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
+
+ clear();
+
+ s.defaultReadObject();
+
+ int size = s.readInt();
+
+ for (int i = 0; i < size; i++) {
+ last.add((T) s.readObject());
+ }
+ }
+
+ static class Node<T> {
+
+ Node<T> pre;
+ Node<T> next;
+
+ int listSize;
+
+ int startingIndex;
+ int endingIndex;
+
+ T[] elementData;
+ int elementDataPointer;
+
+ @SuppressWarnings("unchecked")
+ Node(Node<T> pre, Node<T> next, int listSize) {
+ this.pre = pre;
+ this.next = next;
+ this.listSize = listSize;
+ this.elementData = (T[]) new Object[listSize >>> 1];
+ this.startingIndex = listSize;
+ this.endingIndex = listSize + elementData.length - 1;
+ }
+
+ Node(Node<T> pre, Node<T> next, int listSize, int initialCapacity) {
+ this.pre = pre;
+ this.next = next;
+ this.listSize = listSize;
+ this.elementData = createElementData(initialCapacity);
+ this.startingIndex = listSize;
+ this.endingIndex = listSize + elementData.length - 1;
+ }
+
+ @SuppressWarnings("unchecked")
+ T[] createElementData(int capacity) {
+
+ if (capacity == 0 || capacity == 1) {
+ return (T[]) new Object[DEFAULT_CAPACITY];
+ } else if (capacity > 1) {
+ return (T[]) new Object[capacity];
+ } else {
+ throw new IllegalArgumentException("Illegal Capacity: " + capacity);
+ }
+ }
+
+ boolean isAddable() {
+ return elementDataPointer < elementData.length;
+ }
+
+ void add(T element) {
+ elementData[elementDataPointer++] = element;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("[sIndex: %d - eIndex: %d | elementDataPointer: %d | elementDataLength: %d]", startingIndex, endingIndex, elementDataPointer, elementData.length);
+ }
+ }
+}
\ No newline at end of file