/**
* 90% or more copy from jdk
*/
package com.github.eulerlcs.jmr.algorithm;
import java.util.Arrays;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.RandomAccess;
import java.util.function.Consumer;
public class ArrayList<E> implements List<E>, RandomAccess {
private static final int MAX_ARRAY_SIZE = 1 << 10;
private transient Object[] elementData = new Object[0];
private int size;
private transient int modCount = 0;
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public boolean contains(Object o) {
if (o == null) {
for (Object obi : elementData) {
if (obi == null) {
return true;
}
}
} else {
for (Object obj : elementData) {
if (o.equals(obj)) {
return true;
}
}
}
return false;
}
@Override
public boolean containsAll(Collection<?> c) {
for (Object e : c)
if (!contains(e))
return false;
return true;
}
@Override
public Object[] toArray() {
return Arrays.copyOf(elementData, size, elementData.getClass());
}
@SuppressWarnings("unchecked")
@Override
public <T> T[] toArray(T[] a) {
if (a.length < size) {
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
} else {
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
}
@Override
public boolean add(E e) {
ensureExplicitCapacity(size + 1); // Increments modCount!!
elementData[size] = e;
size++;
return true;
}
@Override
public void add(int index, E element) {
if (index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" + size);
ensureExplicitCapacity(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1, size - index);
elementData[index] = element;
size++;
}
@Override
public E remove(int index) {
if (index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" + size);
modCount++;
@SuppressWarnings("unchecked")
E oldValue = (E) elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
elementData[--size] = null;// clear to let GC do its work
return oldValue;
}
@Override
public boolean remove(Object o) {
int index = -1;
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i] == null) {
index = i;
break;
}
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i])) {
index = i;
break;
}
}
if (index > 0) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
elementData[--size] = null;// clear to let GC do its work
return true;
}
return false;
}
@Override
public boolean removeAll(Collection<?> c) {
boolean modified = false;
for (Object obj : c) {
modified |= remove(obj);
}
return modified;
}
@Override
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureExplicitCapacity(size + numNew);// Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
@Override
public boolean addAll(int index, Collection<? extends E> c) {
if (index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" + size);
Object[] a = c.toArray();
int numNew = a.length;
ensureExplicitCapacity(size + numNew);// Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
@Override
public boolean retainAll(Collection<?> c) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
for (; r < size; r++)
if (c.contains(elementData[r]))
elementData[w++] = elementData[r];
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
return modified;
}
@Override
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
@Override
public List<E> subList(int fromIndex, int toIndex) {
throw new UnsupportedOperationException();
}
@SuppressWarnings("unchecked")
@Override
public E get(int index) {
if (index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" + size);
return (E) elementData[index];
}
@SuppressWarnings("unchecked")
@Override
public E set(int index, E element) {
if (index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size:" + size);
E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}
@Override
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i] == null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
@Override
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size - 1; i >= 0; i--)
if (elementData[i] == null)
return i;
} else {
for (int i = size - 1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (elementData.length > minCapacity) {
return;
} else if (minCapacity > MAX_ARRAY_SIZE) {
throw new OutOfMemoryError();
}
int oldCapacity = elementData.length;
int newCapacity = oldCapacity == 0 ? 10 : (oldCapacity + (oldCapacity >> 1));
if (newCapacity > MAX_ARRAY_SIZE) {
newCapacity = MAX_ARRAY_SIZE;
}
elementData = Arrays.copyOf(elementData, newCapacity);
}
@Override
public Iterator<E> iterator() {
return new Itr();
}
@Override
public ListIterator<E> listIterator() {
return new ListItr(0);
}
@Override
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: " + index);
return new ListItr(index);
}
/**
* fully copy from jdk ArrayList.Itr
*/
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
@Override
public boolean hasNext() {
return cursor != size;
}
@Override
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
@Override
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/**
* fully copy from jdk ArrayList.ListItr
*/
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
@Override
public boolean hasPrevious() {
return cursor != 0;
}
@Override
public int nextIndex() {
return cursor;
}
@Override
public int previousIndex() {
return cursor - 1;
}
@Override
@SuppressWarnings("unchecked")
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
@Override
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
public void add(E e) {
checkForComodification();
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
}