/** * {@inheritDoc} * * <p>This implementation first gets a list iterator (with {@code listIterator()}). Then, it * iterates over the list until the specified element is found or the end of the list is reached. * * @throws ClassCastException {@inheritDoc} * @throws NullPointerException {@inheritDoc} */ public int indexOf(Object o) { ListIterator<E> e = listIterator(); if (o == null) { while (e.hasNext()) if (e.next() == null) return e.previousIndex(); } else { while (e.hasNext()) if (o.equals(e.next())) return e.previousIndex(); } return -1; }
/** * Compares the specified object with this list for equality. Returns {@code true} if and only if * the specified object is also a list, both lists have the same size, and all corresponding pairs * of elements in the two lists are <i>equal</i>. (Two elements {@code e1} and {@code e2} are * <i>equal</i> if {@code (e1==null ? e2==null : e1.equals(e2))}.) In other words, two lists are * defined to be equal if they contain the same elements in the same order. * * <p>This implementation first checks if the specified object is this list. If so, it returns * {@code true}; if not, it checks if the specified object is a list. If not, it returns {@code * false}; if so, it iterates over both lists, comparing corresponding pairs of elements. If any * comparison returns {@code false}, this method returns {@code false}. If either iterator runs * out of elements before the other it returns {@code false} (as the lists are of unequal length); * otherwise it returns {@code true} when the iterations complete. * * @param o the object to be compared for equality with this list * @return {@code true} if the specified object is equal to this list */ public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof List)) return false; ListIterator<E> e1 = listIterator(); ListIterator e2 = ((List) o).listIterator(); while (e1.hasNext() && e2.hasNext()) { E o1 = e1.next(); Object o2 = e2.next(); if (!(o1 == null ? o2 == null : o1.equals(o2))) return false; } return !(e1.hasNext() || e2.hasNext()); }
/** * Removes from this list all of the elements whose index is between {@code fromIndex}, inclusive, * and {@code toIndex}, exclusive. Shifts any succeeding elements to the left (reduces their * index). This call shortens the ArrayList by {@code (toIndex - fromIndex)} elements. (If {@code * toIndex==fromIndex}, this operation has no effect.) * * <p>This method is called by the {@code clear} operation on this list and its subLists. * Overriding this method to take advantage of the internals of the list implementation can * <i>substantially</i> improve the performance of the {@code clear} operation on this list and * its subLists. * * <p>This implementation gets a list iterator positioned before {@code fromIndex}, and repeatedly * calls {@code ListIterator.next} followed by {@code ListIterator.remove} until the entire range * has been removed. <b>Note: if {@code ListIterator.remove} requires linear time, this * implementation requires quadratic time.</b> * * @param fromIndex index of first element to be removed * @param toIndex index after last element to be removed */ protected void removeRange(int fromIndex, int toIndex) { ListIterator<E> it = listIterator(fromIndex); for (int i = 0, n = toIndex - fromIndex; i < n; i++) { it.next(); it.remove(); } }