java有没有天才_帮忙做下啊，JAVA天才进来下

该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

this.element = element;

this.next = next;

this.previous = previous;

}

}

private Entry addBefore(E e, Entry entry) {

Entry newEntry = new Entry(e, entry, entry.previous);

newEntry.previous.next = newEntry;

newEntry.next.previous = newEntry;

size++;

modCount++;

return newEntry;

}

private E remove(Entry e) {

if (e == header)

throw new NoSuchElementException();

E result = e.element;

e.previous.next = e.next;

e.next.previous = e.previous;

e.next = e.previous = null;

e.element = null;

size--;

modCount++;

return result;

}

/**

* @since 1.6

*/

public Iterator descendingIterator() {

return new DescendingIterator();

}

/** Adapter to provide descending iterators via ListItr.previous */

private class DescendingIterator implements Iterator {

final ListItr itr = new ListItr(size());

public boolean hasNext() {

return itr.hasPrevious();

}

public E next() {

return itr.previous();

}

public void remove() {

itr.remove();

}

}

/**

* Returns a shallow copy of this LinkedList. (The elements

* themselves are not cloned.)

*

* @return a shallow copy of this LinkedList instance

*/

public Object clone() {

LinkedList clone = null;

try {

clone = (LinkedList) super.clone();

} catch (CloneNotSupportedException e) {

throw new InternalError();

}

// Put clone into "virgin" state

clone.header = new Entry(null, null, null);

clone.header.next = clone.header.previous = clone.header;

clone.size = 0;

clone.modCount = 0;

// Initialize clone with our elements

for (Entry e = header.next; e != header; e = e.next)

clone.add(e.element);

return clone;

}

/**

* Returns an array containing all of the elements in this list

* in proper sequence (from first to last element).

*

* 

The returned array will be "safe" in that no references to it are

* maintained by this list. (In other words, this method must allocate

* a new array). The caller is thus free to modify the returned array.

*

* 

This method acts as bridge between array-based and collection-based

* APIs.

*

* @return an array containing all of the elements in this list

* in proper sequence

*/

public Object[] toArray() {

Object[] result = new Object[size];

int i = 0;

for (Entry e = header.next; e != header; e = e.next)

result[i++] = e.element;

return result;

}

/**

* Returns an array containing all of the elements in this list in

* proper sequence (from first to last element); the runtime type of

* the returned array is that of the specified array. If the list fits

* in the specified array, it is returned therein. Otherwise, a new

* array is allocated with the runtime type of the specified array and

* the size of this list.

*

* 

If the list fits in the specified array with room to spare (i.e.,

* the array has more elements than the list), the element in the array

* immediately following the end of the list is set to null.

* (This is useful in determining the length of the list only if