Detailed explanation of the remove method in Java AbstractCollection

This article mainly introduces the relevant information on the detailed explanation of the ArrayList instance of the Java collection element. Friends who need it can refer to it.

The detailed explanation of the ArrayList instance of the Java collection element

There is a remove method in the AbstractCollection collection class. This method is suitable for Equipped with many different collections, empty elements are allowed to be deleted. When I looked at this part of the code, I had a question. Why is it deleted directly by using it.remove() here?

public boolean remove(Object o) {
    Iterator<E> it = iterator();
    if (o==null) {
      while (it.hasNext()) {
        if (it.next()==null) {
          it.remove();
          return true;
        }
      }
    } else {
      while (it.hasNext()) {
        if (o.equals(it.next())) {
          it.remove();
          return true;
        }
      }
    }
    return false;
  }

Next, take ArrayList as an example to explain. Its inheritance structure is shown in the figure below. Moreover, ArrayList has an implementation class of Iterator inside it.

Write a test code:

AbstractCollection<String> list = new ArrayList<>();
    list.add("a");
    list.add(null);
    list.add(null);

    Iterator<String> iter = list.iterator();
    while(iter.hasNext()) {
      if(iter.next() == null) {
        iter.remove();
      }
    }
    System.out.println(list);

The key point is still the line iter.next() == null. The source code of next is as follows:

 public E next() {
      checkForComodification();
      int i = cursor;
      if (i >= size)
        throw new NoSuchElementException();
      Object[] elementData = ArrayList.this.elementData;
      if (i >= elementData.length)
        throw new ConcurrentModificationException();
      cursor = i + 1;
      return (E) elementData[lastRet = i];
    }

cusor here represents the index during traversal. When the next method is called, the cusor actually points to the next element of the current element, and lasrRet is used to obtain the data at the current index and return it.

In the remove() method, deletion is done through the index of lastRet.

  public void remove() {
      if (lastRet < 0)
        throw new IllegalStateException();
      checkForComodification();

      try {
        ArrayList.this.remove(lastRet);
        cursor = lastRet;
        lastRet = -1;
        expectedModCount = modCount;
      } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
      }
    }

With the help of the test examples mentioned above, each step can be calculated.

1. Call the next() method, cursor points to element 0, i is assigned the value of cursor, and then cursor is modified to i+1, pointing to element 1, which is the location of null, and lastRet is assigned is 0.
2. Call the next() method. The cursor points to element 1 and assigns it to i. Then the cursor increments through i+1 and becomes 2. LastRet is assigned a value of 1.
3. Execute deletion and delete the element represented by lastRet in the collection. Elements. After the deletion is completed, modify the cursor pointer and make expectedModCount and modCount consistent to avoid fastfail.

【Related recommendations】

1. Java Free Video Tutorial

2. Geek Academy Java Video Tutorial

3. JAVA Tutorial Manual

The above is the detailed content of Detailed explanation of the remove method in Java AbstractCollection. For more information, please follow other related articles on the PHP Chinese website!