Exemple #1
0
 /**
  * {@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;
 }
Exemple #2
0
  /**
   * 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());
  }
Exemple #3
0
 /**
  * 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();
   }
 }