/** * Returns a new list, with the same elements as the current list, but with * a reversed order. **/ @Atomic(readOnly = true) public VArrayList<E> reversed() { return new VArrayList<E>(descendingIterator()); }
@Override public void addFirst(E e) { add(0, e); }
public VArrayList(Collection<? extends E> c) { this(c.size()); addAll(c); }
@Override @Atomic(speculativeReadOnly = true) public boolean add(E e) { int size = size(); ensureCapacity(size + 1); array().put(size, e); this.size.putInt(size + 1); return true; }
@Atomic public void ensureCapacity(int minCapacity) { if (minCapacity <= array().length) { return; } // Calculate new size for array int minCapHighBit = Integer.highestOneBit(minCapacity); int newCapacity = minCapHighBit << 1; if (newCapacity < 0) { newCapacity = Integer.MAX_VALUE; } else if ((minCapacity & (minCapHighBit >> 1)) > 0) { newCapacity += minCapHighBit; } resize(newCapacity); }
@Override @Atomic(speculativeReadOnly = false) public boolean addAll(int index, Collection<? extends E> c) { int size = size(); if (index > size) { throw new IndexOutOfBoundsException(); } ensureCapacity(size + c.size()); return super.addAll(index, c); }
@Override public boolean offerFirst(E e) { addFirst(e); return true; }
@Override public E element() { return getFirst(); }
@Override public E peekFirst() { try { return get(0); } catch (IndexOutOfBoundsException e) { return null; } }
@Override public boolean offerLast(E e) { addLast(e); return true; }
@Override @Atomic(speculativeReadOnly = false) public void clear() { // Let the GC do its job array.put(new VArray<E>(array().length)); size.putInt(0); }
@Override @Atomic(speculativeReadOnly = false) public boolean addAll(Collection<? extends E> c) { if (c.size() == 0) { return false; } int size = size(); ensureCapacity(size + c.size()); VArray<E> array = array(); // Must be done AFTER ensureCapacity! for (E element : c) { array.put(size++, element); } this.size.putInt(size); return true; }
@Override public void push(E e) { addFirst(e); }
public E first() { return getFirst(); }
@Override @Atomic(speculativeReadOnly = false) public void add(int index, E element) { int size = size(); if (index < 0 || index > size) { throw new IndexOutOfBoundsException(); } ensureCapacity(size + 1); VArray<E> array = array(); // Must be done AFTER ensureCapacity! for (int i = size - 1; i >= index; i--) { array.put(i + 1, array.get(i)); } array.put(index, element); this.size.put(size + 1); }