| Methods Summary |
|---|
| public void | add(int location, E object)Inserts the specified object into this {@code LinkedList} at the
specified location. The object is inserted before any previous element at
the specified location. If the location is equal to the size of this
{@code LinkedList}, the object is added at the end.
if (0 <= location && location <= size) {
Link<E> link = voidLink;
if (location < (size / 2)) {
for (int i = 0; i <= location; i++) {
link = link.next;
}
} else {
for (int i = size; i > location; i--) {
link = link.previous;
}
}
Link<E> previous = link.previous;
Link<E> newLink = new Link<E>(object, previous, link);
previous.next = newLink;
link.previous = newLink;
size++;
modCount++;
} else {
throw new IndexOutOfBoundsException();
}
|
| public boolean | add(E object)Adds the specified object at the end of this {@code LinkedList}.
// Cannot call addLast() as subclasses can override
Link<E> oldLast = voidLink.previous;
Link<E> newLink = new Link<E>(object, oldLast, voidLink);
voidLink.previous = newLink;
oldLast.next = newLink;
size++;
modCount++;
return true;
|
| public boolean | addAll(int location, java.util.Collection collection)Inserts the objects in the specified collection at the specified location
in this {@code LinkedList}. The objects are added in the order they are
returned from the collection's iterator.
if (location < 0 || location > size) {
throw new IndexOutOfBoundsException();
}
int adding = collection.size();
if (adding == 0) {
return false;
}
Link<E> previous = voidLink;
if (location < (size / 2)) {
for (int i = 0; i < location; i++) {
previous = previous.next;
}
} else {
for (int i = size; i >= location; i--) {
previous = previous.previous;
}
}
Link<E> next = previous.next;
for (E e : collection) {
Link<E> newLink = new Link<E>(e, previous, null);
previous.next = newLink;
previous = newLink;
}
previous.next = next;
next.previous = previous;
size += adding;
modCount++;
return true;
|
| public boolean | addAll(java.util.Collection collection)Adds the objects in the specified Collection to this {@code LinkedList}.
int adding = collection.size();
if (adding == 0) {
return false;
}
Link<E> previous = voidLink.previous;
for (E e : collection) {
Link<E> newLink = new Link<E>(e, previous, null);
previous.next = newLink;
previous = newLink;
}
previous.next = voidLink;
voidLink.previous = previous;
size += adding;
modCount++;
return true;
|
| public void | addFirst(E object)Adds the specified object at the beginning of this {@code LinkedList}.
Link<E> oldFirst = voidLink.next;
Link<E> newLink = new Link<E>(object, voidLink, oldFirst);
voidLink.next = newLink;
oldFirst.previous = newLink;
size++;
modCount++;
|
| public void | addLast(E object)Adds the specified object at the end of this {@code LinkedList}.
Link<E> oldLast = voidLink.previous;
Link<E> newLink = new Link<E>(object, oldLast, voidLink);
voidLink.previous = newLink;
oldLast.next = newLink;
size++;
modCount++;
|
| public void | clear()Removes all elements from this {@code LinkedList}, leaving it empty.
if (size > 0) {
size = 0;
voidLink.next = voidLink;
voidLink.previous = voidLink;
modCount++;
}
|
| public java.lang.Object | clone()Returns a new {@code LinkedList} with the same elements and size as this
{@code LinkedList}.
try {
LinkedList<E> l = (LinkedList<E>) super.clone();
l.size = 0;
l.voidLink = new Link<E>(null, null, null);
l.voidLink.previous = l.voidLink;
l.voidLink.next = l.voidLink;
l.addAll(this);
return l;
} catch (CloneNotSupportedException e) {
return null;
}
|
| public boolean | contains(java.lang.Object object)Searches this {@code LinkedList} for the specified object.
Link<E> link = voidLink.next;
if (object != null) {
while (link != voidLink) {
if (object.equals(link.data)) {
return true;
}
link = link.next;
}
} else {
while (link != voidLink) {
if (link.data == null) {
return true;
}
link = link.next;
}
}
return false;
|
| public E | element()
return getFirst();
|
| public E | get(int location)
if (0 <= location && location < size) {
Link<E> link = voidLink;
if (location < (size / 2)) {
for (int i = 0; i <= location; i++) {
link = link.next;
}
} else {
for (int i = size; i > location; i--) {
link = link.previous;
}
}
return link.data;
}
throw new IndexOutOfBoundsException();
|
| public E | getFirst()Returns the first element in this {@code LinkedList}.
Link<E> first = voidLink.next;
if (first != voidLink) {
return first.data;
}
throw new NoSuchElementException();
|
| public E | getLast()Returns the last element in this {@code LinkedList}.
Link<E> last = voidLink.previous;
if (last != voidLink) {
return last.data;
}
throw new NoSuchElementException();
|
| public int | indexOf(java.lang.Object object)
int pos = 0;
Link<E> link = voidLink.next;
if (object != null) {
while (link != voidLink) {
if (object.equals(link.data)) {
return pos;
}
link = link.next;
pos++;
}
} else {
while (link != voidLink) {
if (link.data == null) {
return pos;
}
link = link.next;
pos++;
}
}
return -1;
|
| public int | lastIndexOf(java.lang.Object object)Searches this {@code LinkedList} for the specified object and returns the
index of the last occurrence.
int pos = size;
Link<E> link = voidLink.previous;
if (object != null) {
while (link != voidLink) {
pos--;
if (object.equals(link.data)) {
return pos;
}
link = link.previous;
}
} else {
while (link != voidLink) {
pos--;
if (link.data == null) {
return pos;
}
link = link.previous;
}
}
return -1;
|
| public java.util.ListIterator | listIterator(int location)Returns a ListIterator on the elements of this {@code LinkedList}. The
elements are iterated in the same order that they occur in the
{@code LinkedList}. The iteration starts at the specified location.
return new LinkIterator<E>(this, location);
|
| public boolean | offer(E o)
add(o);
return true;
|
| public E | peek()
Link<E> first = voidLink.next;
return first == voidLink ? null : first.data;
|
| public E | poll()
return size == 0 ? null : removeFirst();
|
| private void | readObject(java.io.ObjectInputStream stream)
stream.defaultReadObject();
size = stream.readInt();
voidLink = new Link<E>(null, null, null);
Link<E> link = voidLink;
for (int i = size; --i >= 0;) {
Link<E> nextLink = new Link<E>((E)stream.readObject(), link, null);
link.next = nextLink;
link = nextLink;
}
link.next = voidLink;
voidLink.previous = link;
|
| public E | remove(int location)Removes the object at the specified location from this {@code LinkedList}.
if (0 <= location && location < size) {
Link<E> link = voidLink;
if (location < (size / 2)) {
for (int i = 0; i <= location; i++) {
link = link.next;
}
} else {
for (int i = size; i > location; i--) {
link = link.previous;
}
}
Link<E> previous = link.previous;
Link<E> next = link.next;
previous.next = next;
next.previous = previous;
size--;
modCount++;
return link.data;
}
throw new IndexOutOfBoundsException();
|
| public boolean | remove(java.lang.Object object)
Link<E> link = voidLink.next;
if (object != null) {
while (link != voidLink && !object.equals(link.data)) {
link = link.next;
}
} else {
while (link != voidLink && link.data != null) {
link = link.next;
}
}
if (link == voidLink) {
return false;
}
Link<E> next = link.next;
Link<E> previous = link.previous;
previous.next = next;
next.previous = previous;
size--;
modCount++;
return true;
|
| public E | remove()
return removeFirst();
|
| public E | removeFirst()Removes the first object from this {@code LinkedList}.
Link<E> first = voidLink.next;
if (first != voidLink) {
Link<E> next = first.next;
voidLink.next = next;
next.previous = voidLink;
size--;
modCount++;
return first.data;
}
throw new NoSuchElementException();
|
| public E | removeLast()Removes the last object from this {@code LinkedList}.
Link<E> last = voidLink.previous;
if (last != voidLink) {
Link<E> previous = last.previous;
voidLink.previous = previous;
previous.next = voidLink;
size--;
modCount++;
return last.data;
}
throw new NoSuchElementException();
|
| public E | set(int location, E object)Replaces the element at the specified location in this {@code LinkedList}
with the specified object.
if (0 <= location && location < size) {
Link<E> link = voidLink;
if (location < (size / 2)) {
for (int i = 0; i <= location; i++) {
link = link.next;
}
} else {
for (int i = size; i > location; i--) {
link = link.previous;
}
}
E result = link.data;
link.data = object;
return result;
}
throw new IndexOutOfBoundsException();
|
| public int | size()Returns the number of elements in this {@code LinkedList}.
return size;
|
| public java.lang.Object[] | toArray()Returns a new array containing all elements contained in this
{@code LinkedList}.
int index = 0;
Object[] contents = new Object[size];
Link<E> link = voidLink.next;
while (link != voidLink) {
contents[index++] = link.data;
link = link.next;
}
return contents;
|
| public T[] | toArray(T[] contents)Returns an array containing all elements contained in this
{@code LinkedList}. If the specified array is large enough to hold the
elements, the specified array is used, otherwise an array of the same
type is created. If the specified array is used and is larger than this
{@code LinkedList}, the array element following the collection elements
is set to null.
int index = 0;
if (size > contents.length) {
Class<?> ct = contents.getClass().getComponentType();
contents = (T[]) Array.newInstance(ct, size);
}
Link<E> link = voidLink.next;
while (link != voidLink) {
contents[index++] = (T)link.data;
link = link.next;
}
if (index < contents.length) {
contents[index] = null;
}
return contents;
|
| private void | writeObject(java.io.ObjectOutputStream stream)
stream.defaultWriteObject();
stream.writeInt(size);
Iterator<E> it = iterator();
while (it.hasNext()) {
stream.writeObject(it.next());
}
|
