Java源码学习(JDK11)——java.lang.Collection

} public NavigableSet descendingSet() { return new TreeSet<>(dingMap()); } public int size() { return (); } public boolean isEmpty() { return y(); } public boolean contains(Object o) { return nsKey(o); } public boolean add(E e) { return (e, PRESENT)==null; } public boolean remove(Object o) { return (o)==PRESENT; } public void clear() { (); } public boolean addAll(Collection c) { // Use linear-time version if applicable if (()==0 && () > 0 && c instanceof SortedSet && m instanceof TreeMap) { SortedSet set = (SortedSet) c; TreeMap map = (TreeMap) m; Comparator cc = ator(); Comparator mc = ator(); if (cc==mc || (cc != null && (mc))) { ForTreeSet(set, PRESENT); return true; } } return (c); } public NavigableSet subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) { return new TreeSet<>((fromElement, fromInclusive, toElement, toInclusive)); } public NavigableSet headSet(E toElement, boolean inclusive) { return new TreeSet<>(p(toElement, inclusive)); } public NavigableSet tailSet(E fromElement, boolean inclusive) { return new TreeSet<>(p(fromElement, inclusive)); } public SortedSet subSet(E fromElement, E toElement) { return subSet(fromElement, true, toElement, false); } public SortedSet headSet(E toElement) { return headSet(toElement, false); } public SortedSet tailSet(E fromElement) { return tailSet(fromElement, true); } public Comparator comparator() { return ator(); } public E first() { return ey(); } public E last() { return y(); } // NavigableSet API methods public E lower(E e) { return ey(e); } public E floor(E e) { return ey(e); } public E ceiling(E e) { return gKey(e); } public E higher(E e) { return Key(e); } public E pollFirst() { e = rstEntry(); return (e == null) ? null : ();

add(index++, e); modified = true; } return modified; } // Iterators // 借助内部类来实现 public Iterator iterator() { return new Itr(); } public ListIterator listIterator() { return listIterator(0); } public ListIterator listIterator(final int index) { rangeCheckForAdd(index); return new ListItr(index); } private class Itr implements Iterator { /** * Index of element to be returned by subsequent call to next. */ int cursor = 0; /** * Index of element returned by most recent call to next or * previous. Reset to -1 if this element is deleted by a call * to remove. */ int lastRet = -1; /** * The modCount value that the iterator believes that the backing * List should have. If this expectation is violated, the iterator * has detected concurrent modification. */ int expectedModCount = modCount; public boolean hasNext() { return cursor != size(); } public E next() { checkForComodification(); try { int i = cursor; E next = get(i); lastRet = i; cursor = i + 1; return next; } catch (IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } } public void remove() { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { (lastRet); if (lastRet < cursor) cursor--; lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException e) { throw new ConcurrentModificationException(); } } final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } } private class ListItr extends Itr implements ListIterator { ListItr(int index) { cursor = index; } public boolean hasPrevious() {

elementData = grow(); // 等价于 grow(size+1) minCapacity = size+1 elementData[s] = e; size = s + 1; } public boolean add(E e) { modCount++; add(e, elementData, size); return true; } public void add(int index, E element) { rangeCheckForAdd(index); modCount++; final int s; Object[] elementData; if ((s = size) == (elementData = tData).length) elementData = grow(); opy(elementData, index, elementData, index + 1, s - index); elementData[index] = element; size = s + 1; } public E remove(int index) { ndex(index, size); final Object[] es = elementData; @SuppressWarnings("unchecked") E oldValue = (E) es[index]; fastRemove(es, index); return oldValue; } /** * Private remove method that skips bounds checking and does not * return the value removed. */ private void fastRemove(Object[] es, int i) { modCount++; final int newSize; if ((newSize = size - 1) > i) opy(es, i + 1, es, i, newSize - i); es[size = newSize] = null; } // 数组长度不变 public void clear() { modCount++; final Object[] es = elementData; for (int to = size, i = size = 0; i < to; i++) es[i] = null; } /** * An optimized version of */ private class Itr implements Iterator { /*...*/ } /** * An optimized version of r */ private class ListItr extends Itr implements ListIterator { /*...*/ } private static class SubList extends AbstractList implements RandomAccess { /*...*/ } @Override public void forEach(Consumer action) { eNonNull(action); final int expectedModCount = modCount; final Object[] es = elementData; final int size = ; for (int i = 0; modCount == expectedModCount && i < size; i++) (elementAt(es, i)); if (modCount != expectedModCount) throw new ConcurrentModificationException(); } @Override public Spliterator spliterator() { return new ArrayListSpliterator(0, -1, 0); } /** Index-based split-by-two, lazily initialized Spliterator */ final class ArrayListSpliterator implements Spliterator { /*...*/ }

/** * Links e as last element. */ void linkLast(E e) { /*...*/ } /** * Inserts element e before non-null Node succ. */ void linkBefore(E e, Node succ) { // assert succ != null; final Node pred = ; final Node newNode = new Node<>(pred, e, succ); = newNode; if (pred == null) first = newNode; else = newNode; size++; modCount++; } /** * Unlinks non-null first node f. */ private E unlinkFirst(Node f) { // assert f == first && f != null; final E element = ; final Node next = ; = null; = null; // help GC first = next; if (next == null) last = null; else = null; size--; modCount++; return element; } /** * Unlinks non-null last node l. */ private E unlinkLast(Node l) { /*...*/ } /** * Unlinks non-null node x. */ E unlink(Node x) { // assert x != null; final E element = ; final Node next = ; final Node prev = ; if (prev == null) { first = next; } else { = next; = null; } if (next == null) { last = prev; } else { = prev; = null; } = null; size--; modCount++; return element; } public E getFirst() { final Node f = first; if (f == null) throw new NoSuchElementException(); return ; } public E getLast() { /*...*/ } public E removeFirst() { /*...*/ }

public E removeLast() { /*...*/ } public void addFirst(E e) { /*...*/ } public void addLast(E e) { /*...*/ } public boolean contains(Object o) { return indexOf(o) != -1; } public int size() { /*...*/ } // 尾插 public boolean add(E e) { linkLast(e); return true; } public boolean remove(Object o) { if (o == null) { for (Node x = first; x != null; x = ) { if ( == null) { unlink(x); return true; } } } else { for (Node x = first; x != null; x = ) { if (()) { unlink(x); return true; } } } return false; } public boolean addAll(Collection c) { /*...*/ } public boolean addAll(int index, Collection c) { /*...*/ }

public void clear() { // Clearing all of the links between nodes is "unnecessary", but: // - helps a generational GC if the discarded nodes inhabit // more than one generation // - is sure to free memory even if there is a reachable Iterator for (Node x = first; x != null; ) { Node next = ; = null; = null; = null; x = next; } first = last = null; size = 0; modCount++; } // Positional Access Operations public E get(int index) { checkElementIndex(index); return node(index).item; } public E set(int index, E element) { /*...*/ } public void add(int index, E element) { checkPositionIndex(index); if (index == size) linkLast(element); else linkBefore(element, node(index)); } public E remove(int index) { checkElementIndex(index); return unlink(node(index)); } /**

* Tells if the argument is the index of an existing element. */ private boolean isElementIndex(int index) { return index >= 0 && index < size; } /** * Tells if the argument is the index of a valid position for an * iterator or an add operation. */ private boolean isPositionIndex(int index) { return index >= 0 && index <= size; } /** * Returns the (non-null) Node at the specified element index. */ Node node(int index) { // assert isElementIndex(index); // 根据 index 判断结点在链表的前半段还是后半段 if (index < (size >> 1)) { Node x = first; for (int i = 0; i < index; i++) x = ; return x; } else { Node x = last; for (int i = size - 1; i > index; i--) x = ; return x; } } // Search Operations public int indexOf(Object o) { int index = 0; if (o == null) { for (Node x = first; x != null; x = ) { if ( == null) return index; index++; } } else { for (Node x = first; x != null; x = ) { if (()) return index; index++; } } return -1; } public int lastIndexOf(Object o) { /*...*/ } // Queue operations. public E peek() { final Node f = first; return (f == null) ? null : ; } public E element() { return getFirst(); } public E poll() { final Node f = first; return (f == null) ? null : unlinkFirst(f); } public E remove() { return removeFirst(); } public boolean offer(E e) { return add(e); } // Deque operations public boolean offerFirst(E e) { /*...*/ } public boolean offerLast(E e) { /*...*/ }

public E peekFirst() { /*...*/ } public E peekLast() { /*...*/ } public E pollFirst() { /*...*/ } public E pollLast() { /*...*/ } public void push(E e) { addFirst(e); } public E pop() { return removeFirst(); } public boolean removeFirstOccurrence(Object o) { return remove(o); } public boolean removeLastOccurrence(Object o) { /*...*/ } public ListIterator listIterator(int index) { checkPositionIndex(index); return new ListItr(index); } private class ListItr implements ListIterator { private Node lastReturned; private Node next; private int nextIndex; private int expectedModCount = modCount; ListItr(int index) { // assert isPositionIndex(index); next = (index == size) ? null : node(index); nextIndex = index; } public boolean hasNext() { return nextIndex < size; } public E next() { checkForComodification(); if (!hasNext()) throw new NoSuchElementException(); lastReturned = next; next = ; nextIndex++; return ; } public boolean hasPrevious() { return nextIndex > 0; } public E previous() { checkForComodification(); if (!hasPrevious()) throw new NoSuchElementException(); lastReturned = next = (next == null) ? last : ; nextIndex--; return ; } public int nextIndex() { return nextIndex; } public int previousIndex() { return nextIndex - 1; } public void remove() { checkForComodification(); if (lastReturned == null) throw new IllegalStateException(); Node lastNext = ; unlink(lastReturned); if (next == lastReturned)