java ArrayList.remove()的三种错误用法以及六种正确用法详解

  /**
   * Removes the element at the specified position in this list.
   * Shifts any subsequent elements to the left (subtracts one from their
   * indices).
   *
   * @param index the index of the element to be removed
   * @return the element that was removed from the list
   * @throws IndexOutOfBoundsException {@inheritDoc}
   */
  public E remove(int index) {
    rangeCheck(index);
 
    modCount++;
    E oldValue = elementData(index);
 
    int numMoved = size - index - 1;
    if (numMoved > 0)
      System.arraycopy(elementData, index+1, elementData, index,
               numMoved);
    elementData[--size] = null; // clear to let GC do its work
 
    return oldValue;
  }

    List<Long> list = new ArrayList<>(Arrays.asList(1L, 2L, 3L, 4L, 5L));
    for (int i = 0; i < list.size(); i++) {
      if (i % 2 == 0) {
        list.remove(i);
      }
    }
    //最终得到[2,3,5]

  public boolean remove(Object o) {
    if (o == null) {
      for (int index = 0; index < size; index++)
        if (elementData[index] == null) {
          fastRemove(index);
          return true;
        }
    } else {
      for (int index = 0; index < size; index++)
        if (o.equals(elementData[index])) {
          fastRemove(index);
          return true;
        }
    }
    return false;
  }
 
  /*
   * Private remove method that skips bounds checking and does not
   * return the value removed.
   */
  private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
      System.arraycopy(elementData, index+1, elementData, index,
               numMoved);
    elementData[--size] = null; // clear to let GC do its work
  }

    List<Long> list = new ArrayList<>(Arrays.asList(1L, 2L, 2L, 4L, 5L));
    list.remove(2L);
    //最终得到[1,2,4,5]

  public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
  }
 
  private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable
   {
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;
 
    ArrayList(E[] array) {
      a = Objects.requireNonNull(array);
    }
  }

public boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    // figure out which elements are to be removed
    // any exception thrown from the filter predicate at this stage
    // will leave the collection unmodified
    int removeCount = 0;
    final BitSet removeSet = new BitSet(size);
    final int expectedModCount = modCount;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
      @SuppressWarnings("unchecked")
      final E element = (E) elementData[i];
      if (filter.test(element)) {
        removeSet.set(i);
        removeCount++;
      }
    }
    if (modCount != expectedModCount) {
      throw new ConcurrentModificationException();
    }
 
    // shift surviving elements left over the spaces left by removed elements
    final boolean anyToRemove = removeCount > 0;
    if (anyToRemove) {
      final int newSize = size - removeCount;
      for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
        i = removeSet.nextClearBit(i);
        elementData[j] = elementData[i];
      }
      for (int k=newSize; k < size; k++) {
        elementData[k] = null; // Let gc do its work
      }
      this.size = newSize;
      if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
      }
      modCount++;
    }
 
    return anyToRemove;
  }

  List<Long> list = new ArrayList<>(Arrays.asList(1L, 2L, 2L, 4L, 5L));
  list.removeIf(val -> val == 2L);
  //结果得到[1L,4L,5L]

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
  }
 
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
      for (; r < size; r++)
        if (c.contains(elementData[r]) == complement)
          elementData[w++] = elementData[r];
    } finally {
      // Preserve behavioral compatibility with AbstractCollection,
      // even if c.contains() throws.
      if (r != size) {
        System.arraycopy(elementData, r,
                 elementData, w,
                 size - r);
        w += size - r;
      }
      if (w != size) {
        // clear to let GC do its work
        for (int i = w; i < size; i++)
          elementData[i] = null;
        modCount += size - w;
        size = w;
        modified = true;
      }
    }
    return modified;
  }

List<Long> removeList = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
      if (i % 2 == 0) {
        removeList.add(list.get(i));
      }
    }
    list.removeAll(removeList);

Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
 if (it.next() % 2 == 0)
 it.remove();
}

for (int i = list.size() - 1; i >= 0; i--) {
      if (list.get(i).longValue() == 2) {
        list.remove(i);
      }
    }

String[] arr = new String[3];
List list = new ArrayList(Arrays.asList(arr));

int i=0;
while (i<list.size()) {
 if (i % 2 == 0) {
 list.remove(i);
 }else {
 i++;
 }
}