1 .Iterator迭代器实现原理
Iterator接口
boolean hasNext();//判断是否有可迭代的数据
E next();//获取下一个元素
package com.qf.iterator01; //迭代器的接口 //作用：指定遍历数据的标准 public interface Iterator<E> { //判断是否有可迭代的数据 boolean hasNext(); //获取下一个元素 E next(); //删除功能（默认抛异常，意味着集合实现的迭代器可以选择是否有删除元素的功能） default void remove() { throw new UnsupportedOperationException("remove"); } }
AbstractList 的抽象类，
modCount是一个用于记录修改次数的变量 （外部操作数）package com.qf.iterator01; public abstract class AbstractList<E> { protected int modCount;//5s }
ArrayList底层
这段代码是一个ArrayList类的实现，它继承了AbstractList类。ArrayList是一个动态数组，可以根据需要自动扩容。
下面是对代码的解析：
elementData：是一个Object类型的数组，用于存储元素。size：表示元素的个数。DEFAULT_CAPACITY：默认容量，初始化ArrayList时使用的默认容量大小。DEFAULTCAPACITY_EMPTY_ELEMENTDATA：空内容的数组，用于初始化elementData。MAX_ARRAY_SIZE：最大数组长度，用于限制数组的最大容量。ArrayList()：构造方法，初始化ArrayList对象。add(E e)：向ArrayList中添加元素。在添加之前，通过ensureCapacityInternal方法确保容量足够，然后将元素添加到elementData数组中。ensureCapacityInternal(int minCapacity)：确保容量足够。如果elementData数组为空，则将minCapacity设置为默认容量和minCapacity的较大值；然后调用ensureExplicitCapacity方法进行容量检查。ensureExplicitCapacity(int minCapacity)：进行容量检查。如果需要扩容，则调用grow方法进行扩容。grow(int minCapacity)：扩容方法。根据当前数组的容量，计算新的容量，然后通过Arrays.copyOf方法将元素复制到新的数组中。hugeCapacity(int minCapacity)：计算巨大容量。如果minCapacity小于0，抛出内存溢出异常；否则，返回最大容量值。这样，这段代码实现了一个基本的ArrayList类，具备添加元素和自动扩容的功能。
package com.qf.iterator01;
import java.util.Arrays;
public class ArrayList<E> extends AbstractList<E> {
//元素容器
public Object[] elementData;
//元素个数
private int size;//5
//默认容量
private static final int DEFAULT_CAPACITY = 10;
//空内容的数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//最大数组长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE-8;
public ArrayList() {
elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
//minCapacity - 1
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//minCapacity - 10
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
//minCapacity - 10
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//minCapacity - 10
private void grow(int minCapacity) {
//oldCapacity - 0
int oldCapacity = elementData.length;
//newCapacity - 0
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
//newCapacity - 10
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // 长度小于0就报内存溢出
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
}测试类test01
package com.qf.iterator01;
public class Test01 {
/**
* 知识点：研究Iterator如何遍历
*/
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("CCC");
list.add("DDD");
list.add("EEE");
for(Object obj : list.elementData){
System.out.println(obj);
}
}
}2. ListIterator底层
ListIterator的接口
package com.qf.iterator01;
public interface ListIterator<E> extends Iterator<E> {
boolean hasNext();//判断是否有下一个可迭代的元素
E next();//获取下一个元素
boolean hasPrevious();//判断是否有上一个可迭代的元素
E previous();//获取上一个元素
int nextIndex();//获取下一个元素下标
int previousIndex();//获取上一个元素下标
void remove();//删除元素
void set(E e);//修改元素
void add(E e);//添加元素
}
iterator的接口
package com.qf.iterator01;
//迭代器的接口
//作用：指定遍历数据的标准
public interface Iterator<E> {
//判断是否有可迭代的数据
boolean hasNext();
//获取下一个元素
E next();
//删除功能（默认抛异常，意味着集合实现的迭代器可以选择是否有删除元素的功能）
default void remove() {
throw new UnsupportedOperationException("remove");
}
}AbstractList的抽象类， 代码中定义了一个名为
modCount的protected修饰的整型变量，它用于记录对集合的修改次数 。protected修饰符表示该变量可以被子类访问，但不能被其他包中的类访问。
package com.qf.iterator01;
public abstract class AbstractList<E> {
protected int modCount;//5
}ArrayList类
以下是对代码的解析：
ArrayList(int initialCapacity)：带有初始容量参数的构造方法。根据给定的初始容量创建一个ArrayList对象。size()：返回ArrayList中元素的个数。add(int index, E element)：在指定位置插入元素。首先进行下标的合法性检查，然后根据需要进行扩容，并通过System.arraycopy方法进行元素的移动，最后将新元素插入到指定位置。remove(Object o)：移除指定元素。如果元素为null，则遍历ArrayList找到第一个为null的元素进行移除；如果元素不为null，则通过equals方法找到第一个与指定元素相等的元素进行移除。remove(int index)：移除指定位置的元素。首先进行下标的合法性检查，然后通过System.arraycopy方法将元素进行移动，最后将最后一个元素设为null。set(int index, E element)：将指定位置的元素替换为新的元素。首先进行下标的合法性检查，然后将新元素赋值给指定位置的元素，并返回被替换的旧元素。Iterator()：获取迭代器的方法。ListIterator()：获取ListIterator的方法。Itr内部类：实现了Iterator接口，用于实现ArrayList的迭代功能。使用游标cursor和遍历到的当前元素的下标lastRet来追踪迭代的状态。ListItr内部类：继承了Itr，实现了ListIterator接口，用于实现ArrayList的双向迭代功能。添加了hasPrevious()、previous()、nextIndex()、previousIndex()、set(E e)、add(E e)等方法。这样，这段代码实现了一个完整的ArrayList类，具备添加、删除、修改、迭代等功能。
package com.qf.iterator01;
import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.NoSuchElementException;
public class ArrayList<E> extends AbstractList<E> {
//元素容器
public Object[] elementData;
//元素个数
private int size;//5
//默认容量
private static final int DEFAULT_CAPACITY = 10;
//空内容的数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//空内容的数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//最大数组长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE-8;
public ArrayList() {
elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public int size() {
return size;
}
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
//插入元素
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // 判断是否扩容
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException("下标越界:" + index);
}
//minCapacity - 1
private void ensureCapacityInternal(int minCapacity) {
//使用无参构造创建ArrayList，第一次添加元素时进入的判断 -- 目的：确定初始化数组的长度
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//minCapacity - 10
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
//minCapacity - 10
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//minCapacity - 10
private void grow(int minCapacity) {
//oldCapacity - 0
int oldCapacity = elementData.length;
//newCapacity - 0
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
//newCapacity - 10
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // 长度小于0就报内存溢出
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
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 void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException("index:" + index);
}
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;
}
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
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;
}
public E set(int index, E element) {
rangeCheck(index);//判断下标是否合法
E oldValue = elementData(index);//通过下标获取到元素
elementData[index] = element;//把新的元素赋值给指定下标的位置
return oldValue;//返回被替换的值
}
//获取迭代器的方法
public Iterator<E> Iterator(){
return new Itr();
}
public ListIterator<E> listIterator() {
return new ListItr(0);
}
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
public class Itr implements Iterator<E>{
//游标 -- 判断是否有可迭代的数据的变量
int cursor; //0
//遍历到的当前元素的下标
int lastRet = -1;//-1
//内部操作数
int expectedModCount = modCount;//5
@Override
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
@Override
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];
}
final void checkForComodification() {
if(expectedModCount != modCount){
throw new ConcurrentModificationException();
}
}
@Override
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
//迭代器中删除功能还是依赖于ArrayList的删除功能
ArrayList.this.remove(lastRet);
//把当前元素的下标赋值给游标
cursor = lastRet;
//将-1赋值给lastRet，说明该元素删除
lastRet = -1;
//将外部操作数赋值给内部操作数
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
public class ListItr extends Itr implements ListIterator<E>{
public ListItr(int index) {
cursor = index;
}
@Override
public boolean hasPrevious() {
return cursor != 0;
}
@SuppressWarnings("unchecked")
@Override
public E previous() {
checkForComodification();//判断外部操作数和内部操作数是否一致
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
@Override
public int nextIndex() {
return cursor;
}
@Override
public int previousIndex() {
return cursor-1;
}
@Override
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(lastRet, e);//依赖于外部类ArrayList的set方法
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
public void add(E e) {
checkForComodification();//判断外部操作数和内部操作数是否一致
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;//重新将外部操作数赋值给内部操作数
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
}3. LinkedList底层
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
//外部操作数
protected transient int modCount = 0;
public ListIterator<E> listIterator() {
return listIterator(0);
}
}
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
public Iterator<E> iterator() {
return listIterator();
}
public ListIterator<E> listIterator() {
return listIterator(0);
}
public ListIterator<E> listIterator(final int index) {
rangeCheckForAdd(index);
return new ListItr(index);
}
}
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>{
//元素个数
transient int size = 0;
//开始节点
transient Node<E> first;
//结束节点
transient Node<E> last;
public LinkedList() {
}
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
//index - 0
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
//index - 0
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
//获取指定下标上的节点对象
//index - 0
Node<E> node(int index) {
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
//节点类
private static class Node<E> {
E item; ---------- 元素
Node<E> next; ---- 下一个节点的引用地址
Node<E> prev; ---- 上一个节点的引用地址
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;//第一个节点
private Node<E> next;//获取第三个节点
private int nextIndex;//2
private int expectedModCount = modCount;//3
ListItr(int 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;//lastReturned - 第二个节点
next = next.next;//获取第三个节点
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
}LinkedList<String> list = new LinkedList<>();
list.add("张三");
list.add("李四"）;
list.add("王五");
