（一）ArrayList，可自动扩充容量的动态数组
public class ArrayList<E> extends AbstractList<E> implements List<E>,
RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = 8683452581122892189L;
/**
*
* 所有ArrayList的元素都存储在此对象数组当中
* ArrayList的容量就是此数组的长度
*/
private transient Object[] elementData;
/**
* 实际拥有的元素的数量
*
* @serial
*/
private int size;
/**
* 构造方法一，指定elementData数组初始长度
*/
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0) //小于0则抛出IllegalArgumentException
throw new IllegalArgumentException("Illegal Capacity: "
+ initialCapacity);
this.elementData = new Object[initialCapacity];
}
/**
* 构造方法二，默认elementData数组初始长度为10
*/
public ArrayList() {
this(10);
}
/**
* 构造方法三，构造一个包含指定 collection 的元素的List
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray(); //toArray方法由AbstractCollection实现，返回一个对象数组
size = elementData.length; //元素的顺序是由迭代器迭代顺序决定的,详情见toArray方法实现
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class) //如果返回的不是一个数组对象
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
/**
* 修剪ArrayList的容量为实际size长度
*/
public void trimToSize() {
modCount++; //此方法改变了数组结构，需要检测是否同步
int oldCapacity = elementData.length;
if (size < oldCapacity) {
elementData = Arrays.copyOf(elementData, size);
}
}
/**
*
* 扩充数组容量，并指定其最小的容量，即至少容量大小为minCapacity
*/
public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) { //指定最小容量比原来容量大才扩充
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3) / 2 + 1; //扩充原容量的1.5倍加1
if (newCapacity < minCapacity) //扩充后还是小于要求的最小容量，则扩充容量为最小容量
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
/**
* 返回List中的元素个数
*/
public int size() {
return size;
}
/**
* List是否不含元素
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 查看o是否包含在ArrayList中，内部调用了indexOf方法实现
*/
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
/**
* 父类AbstractList的indexOf方法使用的是list迭代器遍历元素
* 这里重写了indexOf方法直接遍历数组即可
* 返回指定元素第一次在数组中出现的索引
* 如果找不到此元素则返回-1
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i] == null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
/**
* 基本同上
*/
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size - 1; i >= 0; i--)
if (elementData[i] == null)
return i;
} else {
for (int i = size - 1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
/**
*
* 返回ArrayList的浅拷贝实例对象，包含所有元素
*/
public Object clone() {
try {
ArrayList<E> v = (ArrayList<E>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) { //如果未实现Cloneable则会抛出CloneNotSupportedException
throw new InternalError();
}
}
/**
*
* 返回的对象数组是安全的，因为它是一个全新的对象
* 操作返回的数组并不会影响到ArrayList对象
*
*/
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
/**
* 返回一个指定类型的包含List所有元素的数组
*/
public <T> T[] toArray(T[] a) {
if (a.length < size) //如果a的长度小于List元素个数
return (T[]) Arrays.copyOf(elementData, size, a.getClass()); //以指定类型返回一个新数组，长度为size
System.arraycopy(elementData, 0, a, 0, size); //否则把elementData中元素复制到a
if (a.length > size) //如果a的长度大于size则在最后位置加一个null元素，等于的话就不用加了
a[size] = null; //这对了解它的实际长度很有效
return a;
}
// Positional Access Operations
public E get(int index) {
RangeCheck(index); //检查是否越界
return (E) elementData[index]; //直接返回数组某位置的元素即可
}
/**
* 对数组指定所有的值进行替换，并返回上一个值
*/
public E set(int index, E element) {
RangeCheck(index); //检查是否越界
E oldValue = (E) elementData[index]; //so easy
elementData[index] = element;
return oldValue;
}
/**
* 在数组size位置添加一个元素
*
*/
public boolean add(E e) {
ensureCapacity(size + 1); // modCount++,并检查是否需要扩充容量
elementData[size++] = e; //size++
return true;
}
/**
*
* 在指定位置添加一个元素，当前在此位置的元素以及其后面的元素都要向后移动一个位置
* 此方法的效率较低
*
*/
public void add(int index, E element) {
if (index > size || index < 0) //检查是否越界
throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+ size);
ensureCapacity(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1, size
- index); //把原来index位置的元素，复制到index+1的位置，后面的size-index-1长度的元素依次复制
elementData[index] = element; //空出的index位置的元素设为element
size++;
}
/**
*
* 移除指定位置的元素，其后面的元素都要向左移动一个位置
* 此方法的效率较低
*/
public E remove(int index) {
RangeCheck(index);
modCount++; //modCount是为了检测是否发生了并发操作，详细见AbstractList类
E oldValue = (E) elementData[index];
int numMoved = size - index - 1; //与add相比少移一个元素
if (numMoved > 0) //是否移除的是最后一个元素
System.arraycopy(elementData, index + 1, elementData, index,
numMoved); //index位置的元素被移除了，原来index+1位置的元素复制到index位置，随后的元素依次复制
elementData[--size] = null; // Let gc do its work，size位置的元素空出来了
return oldValue;
}
/**
*
* 如果o在List中存在，移除第一次出现在List中的o元素
* 如果o在List中不存在，不做任何操作
*
*/
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;
}
/*
*
* 与remove(int index)方法差不多，
* 不过不用检测是否越界与返回原来的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; // Let gc do its work
}
/**
* 移除所有元素，即把所有元素设为null，size=0
*/
public void clear() {
modCount++;
// Let gc do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
/**
* 把a中所有元素添加到数组尾部
*/
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew); //从size位置开始复制a
size += numNew; //size增加
return numNew != 0;
}
/**
*
* 在指定位置开始添加指定集合c中的所有元素
* 当前位置及其随后位置的元素后移
*/
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0) //检测是否越界
throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+ size);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
int numMoved = size - index; //移动元素数量
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved); //把原来index位置的元素，复制到index+numNew的位置，后面的size-index-1长度的元素依次复制
System.arraycopy(a, 0, elementData, index, numNew); //空出来的位置填充c
size += numNew;
return numNew != 0;
}
/**
*
* 移除所有从fromIndex(包含)到toIndex(不包含)范围内的元素，
* 左移随后的元素.如果toIndex=fromIndex，此操作无影响
*
*/
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved); //把toIndex位置的元素复制到fromIndex，随后的元素依次复制，总共复制numMoved个元素
// Let gc do its work
int newSize = size - (toIndex - fromIndex);
while (size != newSize) //这里是为了让gc工作，不直接把size设为newSize
elementData[--size] = null;
}
/**
*
* 这里并没有检测index小于0的情况
* 它总是由数组自己检测，抛出的异常也不同,为ArrayIndexOutOfBoundsException
*/
private void RangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+ size);
}
/**
* 序列化ArrayList，保存ArrayList实例状态
* 保存的是数组长度，及其所有元素
*
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// 写入数组长度
s.writeInt(elementData.length);
// 按顺序写入所有元素
for (int i = 0; i < size; i++)
s.writeObject(elementData[i]);
if (modCount != expectedModCount) { //检测到了并发操作
throw new ConcurrentModificationException();
}
}
/**
* Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
* deserialize it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// 读出数组长度
int arrayLength = s.readInt();
Object[] a = elementData = new Object[arrayLength]; //保存
// 依次读出所有元素
for (int i = 0; i < size; i++)
a[i] = s.readObject();
}
}
（二）LikedList(双向循环链表)
public class LinkedList<E> extends AbstractSequentialList<E> implements
List<E>, Deque<E>, Cloneable, java.io.Serializable {
//在第一个节点之前附设的一个节点称为头结点，有元素添加会重设值
//此变量在序列化时不保存
private transient Entry<E> header = new Entry<E>(null, null, null);
private transient int size = 0; //List存储的Entry对象个数
/**
* 构造方法一，空链表
*/
public LinkedList() {
header.next = header.previous = header; //只有一个头结点的链表
}
/**
* 构造方法二，构造含有指定集合c中所有元素的链表
* 具体见addAll方法
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
/**
* 获取第一个元素的值，即头结点的下一个元素的数据部分
*/
public E getFirst() {
if (size == 0)
throw new NoSuchElementException();
return header.next.element;
}
/**
* 双向循环链表，你懂得
*/
public E getLast() {
if (size == 0)
throw new NoSuchElementException();
return header.previous.element;
}
/**
* 移除第一个元素，具体见remove()方法
*/
public E removeFirst() {
return remove(header.next);
}
/**
* 移除最后一个元素
*/
public E removeLast() {
return remove(header.previous);
}
/**
*
* 在链表开始位置添加一个元素
* 详情见addBefore()
*/
public void addFirst(E e) {
addBefore(e, header.next);
}
/**
* 在链表最后位置添加一个元素
* 详情见addBefore()
*/
public void addLast(E e) {
addBefore(e, header);
}
/**
* 查看链表是否包含元素o
* 详细见indexOf()方法
*/
public boolean contains(Object o) {
return indexOf(o) != -1;
}
/**
* 链表所含元素的数量
*/
public int size() {
return size;
}
/**
* 跟addLast()方法类似，添加成功返回true
*/
public boolean add(E e) {
addBefore(e, header);
return true;
}
/**
* 假如链表中含有一个或多个o对象，移除第一次出现的o
* 如果找不到o返回false
*/
public boolean remove(Object o) {
if (o == null) {
for (Entry<E> e = header.next; e != header; e = e.next) { //从第一个元素开始遍历，每一个Entry对象都包含它下一个元素的信息
if (e.element == null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
/**
*
* 把c中所有元素按顺序添加到链表尾部
*/
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
/**
*
* 在指定位置按顺序添加c中所有元素带List中
*
*/
public boolean addAll(int index, Collection<? extends E> c) {
if (index < 0 || index > size) //检查是否越界，=size表示添加到最后
throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+ size);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
modCount++; //对链表结构产生 影响的操作modCount都要加1，通过modCount可以检查是否对链表进行了并发操作
Entry<E> successor = (index == size ? header : entry(index));
Entry<E> predecessor = successor.previous;
for (int i = 0; i < numNew; i++) { //这里不难，画一个图就出来了，主要是初始化c和修改指针
//暂时使其next为successor，因为e会赋给前驱,而每次遍历都要修改其前驱的next
Entry<E> e = new Entry<E>((E) a[i], successor, predecessor); //把c中元素依次存入Entry，设置其前驱和后继。
predecessor.next = e; //重新设置前驱的next指针
predecessor = e; //让e变为前驱
}
successor.previous = predecessor; //successor的前驱为c中最后一个元素的引用
size += numNew; //长度加
return true;
}
/**
* 移除链表中所有元素
*/
public void clear() {
Entry<E> e = header.next;
while (e != header) { //表示不是只有一个头结点的空链表
Entry<E> next = e.next;
e.next = e.previous = null; //let gc work
e.element = null;
e = next;
}
header.next = header.previous = header; //初始头结点
size = 0;
modCount++;
}
// Positional Access Operations
/**
* 返回指定位置的元素时
*/
public E get(int index) {
return entry(index).element;
}
/**
* 设置指定位置的元素
*/
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}
/**
*
* 把指定元素添加到指定位置，需先定位到此位置的节点
* 详情见addBefore()
*/
public void add(int index, E element) {
addBefore(element, (index == size ? header : entry(index)));
}
/**
* 移除指定位置的元素
*/
public E remove(int index) {
return remove(entry(index));
}
/**
*
* 返回指定索引位置的Entry对象，需要依次遍历得到。
* 这里稍做了一下优化，如果index < size/2 从前面开始遍历
* 如果index >= size/2 从后面开始遍历
*/
private Entry<E> entry(int index) {
if (index < 0 || index >= size) //index在0(包含)到size(不包含)之间，索引从0开始
throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+ size);
Entry<E> e = header;
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next; //依次调用e.next才能得到,需调用index+1次，因为它是从头结点开始的
} else {
for (int i = size; i > index; i--)
e = e.previous; //依次调用e.previous才能得到
}
return e;
}
// Search Operations
/**
*
* 返回o第一次出现的位置，如果在List中找不到o返回-1
*/
public int indexOf(Object o) {
int index = 0; //链表的索引也是从0开始
if (o == null) {
for (Entry e = header.next; e != header; e = e.next) { //从头结点开始，依次遍历
if (e.element == null)
return index;
index++;
}
} else {
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element))
return index;
index++;
}
}
return -1;
}
/**
* 双向循环链表，从后面开始遍历即可
*/
public int lastIndexOf(Object o) {
int index = size;
if (o == null) {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (e.element == null)
return index;
}
} else {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (o.equals(e.element))
return index;
}
}
return -1;
}
// Queue operations.有关队列的基本操作
/**
* 如果链表长度不为空，获取第一个元素
* 否则返回null
*/
public E peek() {
if (size == 0)
return null;
return getFirst();
}
/**
* 跟peek方法相似，不过这里size为0的话直接抛出异常
*/
public E element() {
return getFirst();
}
/**
* 如果链表长度不为空，移除第一个元素,并返回它
* 否则返回null
*/
public E poll() {
if (size == 0)
return null;
return removeFirst();
}
/**
* 与poll方法类似，不过长度为空，即header.next = header
* 抛出NoSuchElementException
*/
public E remove() {
return removeFirst();
}
/**
* 添加一个元素到链表尾部
*/
public boolean offer(E e) {
return add(e);
}
// Deque operations
/**
* 添加一个元素到头结点之后，原来的第一个节点之前
*/
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
/**
* 在尾部添加一个元素
*/
public boolean offerLast(E e) {
addLast(e);
return true;
}
/**
* 获取第一个元素，如果size为0，返回空
* 否则返回第一个元素
*/
public E peekFirst() {
if (size == 0)
return null;
return getFirst();
}
/**
* 获取最后一个元素，如果size为0，返回空
* 否则返回最后一个元素
*/
public E peekLast() {
if (size == 0)
return null;
return getLast();
}
/**
*
* 移除第一个元素并返回它
* 如果size为0则直接返回null
*/
public E pollFirst() {
if (size == 0)
return null;
return removeFirst();
}
/**
* 移除最后一个元素并返回它
* 如果size为0则直接返回null
*/
public E pollLast() {
if (size == 0)
return null;
return removeLast();
}
/**
* 在开始位置添加一个元素
*/
public void push(E e) {
addFirst(e);
}
/**
* 移除第一个元素
*/
public E pop() {
return removeFirst();
}
/**
*
* 移除第一次出现的指定的元素
* 如果遍历整个List后没有找到o，则不做任何改变
*
*/
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
/**
* 这个差不多，从后面开始遍历即可
*/
public boolean removeLastOccurrence(Object o) {
if (o == null) {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (e.element == null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
/**
*
* 返回一个list-iterator.
*/
public ListIterator<E> listIterator(int index) {
return new ListItr(index);
}
/**
* 重新 实现ListIterator，使其跟符合链表的特性
* iterator方法由AbstractSequentialList实现了，
* 但是调用的还是本ListIterator。只不过只能使用iterator接口的方法
* */
private class ListItr implements ListIterator<E> {
private Entry<E> lastReturned = header; //上一次调用next或previous返回的元素，没有调用next则为头结点
private Entry<E> next; //下一次调用next方法返回的元素
private int nextIndex; //下一次调用next返回的元素的索引
private int expectedModCount = modCount; //用来检测遍历过程中是否产生了并发操作
ListItr(int index) { //构造器，是迭代器定位到index位置，要返回index位置的元素需调用一次next()方法时
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: " + index
+ ", Size: " + size);
if (index < (size >> 1)) { //从前面开始遍历
next = header.next; //这是index为0的元素
for (nextIndex = 0; nextIndex < index; nextIndex++)
next = next.next; //最终next为第index个元素，index从0开始
} else { //从后面开始遍历
next = header;
for (nextIndex = size; nextIndex > index; nextIndex--)
next = next.previous; //最终next为第index个元素，index从0开始
}
}
public boolean hasNext() { //size位置可没有元素
return nextIndex != size;
}
public E next() {
checkForComodification();
if (nextIndex == size)
throw new NoSuchElementException();
lastReturned = next;
next = next.next; //这里与ArrayList中的cursor何其相似
nextIndex++;
return lastReturned.element;
}
public boolean hasPrevious() {
return nextIndex != 0;
}
public E previous() {
if (nextIndex == 0)
throw new NoSuchElementException();
lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
}
public int nextIndex() { //返回下一次调用next返回的元素的索引
return nextIndex;
}
public int previousIndex() { //返回下一次调用previous返回的元素的索引
return nextIndex - 1;
}
public void remove() {
checkForComodification();
Entry<E> lastNext = lastReturned.next;
try {
LinkedList.this.remove(lastReturned); //移除上一层调用next()或previous返回的元素
} catch (NoSuchElementException e) {
throw new IllegalStateException();
}
if (next == lastReturned) //表明是调用previous后才调用remove方法
next = lastNext;
else
nextIndex--; //元素减少。nextIndex--
lastReturned = header; //重置lastReturned
expectedModCount++;
}
public void set(E e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
}
public void add(E e) {
checkForComodification();
lastReturned = header;
addBefore(e, next); //在上一次调用next返回的元素之后，在上次调用previous返回的元素之前添加e
nextIndex++; //元素增加，索引增加，保证下次调用next()不是返回添加的元素
expectedModCount++;
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/**
* LinkedList的元素节点，保存当前节点的元素
* 以及下一个节点，和上一个节点的引用
* 由此看出LinkedList是一个双向链表
*/
private static class Entry<E> {
E element; //当前节点元素
Entry<E> next; //下一个节点引用
Entry<E> previous; //上一个节点引用
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
/**
* 在entry之前添加一个节点e
*
*/
private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous); //新节点的前驱和后继，只有一个元素的话前驱和后继都为header
newEntry.previous.next = newEntry; //新节点的前驱的后继为新节点，只包含newEntry一个元素的话修改的是头结点的next
newEntry.next.previous = newEntry; //新节点的后继的前驱为新节点,只包含newEntry一个元素的话修改的是头结点的previous
size++;
modCount++;
return newEntry;
}
/**
* 移除指定节点
*/
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();
E result = e.element;
//修改节点指针
e.previous.next = e.next; //e的前驱的后继等于e的后继
e.next.previous = e.previous; //e的后继的前驱等于e的前驱
e.next = e.previous = null; //let gc work
e.element = null;
size--; //size--
modCount++;
return result;
}
/**
* 逆序返回所有元素的迭代器
*/
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
/** Adapter to provide descending iterators via ListItr.previous */
private class DescendingIterator implements Iterator {
final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}
/**
* 返回一个LikedList的浅拷贝对象
*/
public Object clone() {
LinkedList<E> clone = null;
try {
clone = (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
// Put clone into "virgin" state，即重置其为初始状态
clone.header = new Entry<E>(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0;
// 初始化克隆对象
for (Entry<E> e = header.next; e != header; e = e.next)
clone.add(e.element);
return clone;
}
/**
* 返回一个新建对象数组，包含链表中所有元素
*/
public Object[] toArray() {
Object[] result = new Object[size]; //新建一size长度对象数组
int i = 0;
for (Entry<E> e = header.next; e != header; e = e.next) //遍历赋值
result[i++] = e.element;
return result;
}
/**
* 所有toArray方法都是一个思想...
* 只是遍历方式不同
* */
public <T> T[] toArray(T[] a) {
if (a.length < size) //如果指定数组长度小于size，新建一数组
a = (T[]) java.lang.reflect.Array.newInstance(a.getClass()
.getComponentType(), size);
int i = 0;
Object[] result = a;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
if (a.length > size) //同ArrayList
a[size] = null;
return a;
}
private static final long serialVersionUID = 876323262645176354L;
/**
* 序列化LikedList，保存其状态
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
//添加一些序列化的额外信息，表明它是一个序列化的文件
s.defaultWriteObject();
// 写长度
s.writeInt(size);
// 写元素
for (Entry e = header.next; e != header; e = e.next)
s.writeObject(e.element);
}
/**
* 从流中读取
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// 读长度
int size = s.readInt();
// 初始化header
header = new Entry<E>(null, null, null);
header.next = header.previous = header;
// 按顺序写入所有元素
for (int i = 0; i < size; i++)
addBefore((E) s.readObject(), header);
}
}
（三）HashMap(数组加链表的结合体)
/**
* 作用：用于实现快速查找
* HashMap实现的数据结构：动态数组和链表的结合体
* */
public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>,
Cloneable, Serializable {
/**
* 默认初始数组容量，必须为2的幂
*/
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
*
* 最大容量为1 * 2^30 即2的30次方
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
*
* hashMap的加载系数，当数组中的元素增多时，通过hash函数算出的数组下标
* 相同几率增加。为保证查找的效率，当数组中的元素超过
* load_factor * table.length 时就要扩充容量
* 默认加载系数为0.75
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
*
* 数组存放Entry对象，单向链表的第一个元素，
* 通过它可以遍历整个链表。
* table长度会在需要时进行扩充，table长度始终为2的幂
*/
transient Entry[] table;
/**
* key-value键值对个数
*/
transient int size;
/**
* HashMap size >= threshlod时就扩充数组容量
*/
int threshold;
/**
* hash表加载因子
*/
final float loadFactor;
/**
*
* hash表发生结构性改变的次数，这些方法包括，put，remove等对size进行改变的操作
* 用iterator遍历时可以用来检测是否对HashMap进行了并发操作
*/
transient volatile int modCount;
/**
* 根据指定的初始容量和加载系数构建hashMap
* 初始容量如果不是2的幂，会被构造成2的幂
*/
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: "
+ initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: "
+ loadFactor);
//找到一个2的幂的数，使其大于等于初始容量
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1; // capacity = capacity << 1,左移一位
this.loadFactor = loadFactor;
threshold = (int) (capacity * loadFactor);
table = new Entry[capacity];
init(); //所有构造方法都含有此空方法，做一些其他初始化操作。根据业务要求，可由其子类实现
}
/**
* 根据指定容量与默认加载系数构建HashMap
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 采用默认容量16与默认加载系数0.75构建HashMap
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
threshold = (int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}
/**
*
* 根据指定Map中的键值对,默认加载因子构建HashMap
*/
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, //size要小于容量*0.75
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
putAllForCreate(m);
}
// internal utilities
/**
*
* 在new table之后，在添加元素之前被调用
*/
void init() {
}
/**
*
* hash算法，根据key的hashCode计算其hash值
* 此算法看的一知半解，大家有兴趣可以查看其它资料
* >>>无符号右移 ^按位异或
*/
static int hash(int h) {
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
/**
* 根据hash值与数组长度计算其数组索引。
* length为2的幂，使不同hash通过h&(length-1)产生的索引尽量不同，即减少碰撞。
* 如果产生的索引都不同，通过找到索引就可以直接找到value，而不需要遍历链表。
* 可以使产生的索引始终在table索引范围之内
* 此方法详细解析可见：http://www.iteye.com/topic/539465
*/
static int indexFor(int h, int length) {
return h & (length - 1);
}
/**
* 键值对数目
*/
public int size() {
return size;
}
/**
* 判断hashMap是否为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
*
* 通过key值获得value，如果没有找到此key则返回null。
* 不过返回null也可能是其value为null
* 通过contain方法可判断Map中是否含有此键
*
*/
public V get(Object key) {
if (key == null) //空键另外处理
return getForNullKey();
int hash = hash(key.hashCode());
//定位到index，并查看e的下一个节点是否为null，否则继续遍历
for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
return null;
}
/**
*
* 空键的hash值为0，所以其数组中的索引为0.
* 独立把此方法分离出来是为了提高两个最常用的方法get和put的性能，
* 但在其它情况下此方法被合并了.
*/
private V getForNullKey() {
for (Entry<K, V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
/**
* 如果Map中含有此key返回true.
* 具体见getEntry.
*/
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
/**
*
* 通过返回Entry而不是value可确保Map中是否含有此key
*/
final Entry<K, V> getEntry(Object key) {
int hash = (key == null) ? 0 : hash(key.hashCode());
for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
if (e.hash == hash
&& ((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
/**
*
* replaced.
* 通过指定的key值存储指定value，如果Map中含有此key则用指定value替换old value
*/
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K, V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this); //当你调用put并在替换老值时会调用此方法，假如你在这个时候想做一些额外操作可继承Entry重写此方法
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
private V putForNullKey(V value) {
for (Entry<K, V> e = table[0]; e != null; e = e.next) {
if (e.key == null) { //如果含有此null key替换老值
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0); //否则添加此Entry到数组
return null;
}
/**
*
* 此方法用来替代put方法，不会调整table大小。
* 此方法在确认map键值对个数始终小于table.length * load_factor，
* 添加元素时调用。主要是为了提高性能
*/
private void putForCreate(K key, V value) {
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
/**
*
* 查看是否存在同样的key值，如果有就替换其value
*/
for (Entry<K, V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash
&& ((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
//否则添加一个Entry对象
createEntry(hash, key, value, i);
}
/**
* 依次遍历添加
* */
private void putAllForCreate(Map<? extends K, ? extends V> m) {
for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m
.entrySet().iterator(); i.hasNext();) {
Map.Entry<? extends K, ? extends V> e = i.next();
putForCreate(e.getKey(), e.getValue());
}
}
/**
*
* 当HashMap中元素越来越多时，发生碰撞的几率增大，为提高效率，当元素超过
* threshold时就要对数组进行扩充，扩充后，原数组中所有数据都要重新计算
* 其在新数组中的位置，所以每扩充一次对性能影响是非常大的。
*/
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) { //如果数组容量已经最大，不再扩充。
threshold = Integer.MAX_VALUE; //使threshold = Integer.MAX_VALUE,使resize方法不再被调用
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int) (newCapacity * loadFactor);
}
/**
*
* 把table中所有的Entry对象转移到newTabel
*/
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
Entry<K, V> e = src[j];
if (e != null) {
src[j] = null; //只置空第一个节点即可，因为此节点存在数组中
do {
Entry<K, V> next = e.next;
int i = indexFor(e.hash, newCapacity); //根据新容量重新计算index
e.next = newTable[i]; //最后添加的节点放最前面
newTable[i] = e;
e = next;
} while (e != null);
}
}
}
/**
*
* 把所有元素从知道map中复制到本map
*/
public void putAll(Map<? extends K, ? extends V> m) {
int numKeysToBeAdded = m.size();
if (numKeysToBeAdded == 0)
return;
/*
*
* 如果numKeysToBeAdded大于或等于threshold就扩展map
* 这是一个保守的方法。本来的条件应该是(m.size() + size) >= threshold,
* 但是如果所有被添加的元素的key值在本map中都存在，map扩充的容量将是
* 最佳容量的两倍。这极大的浪费了空间，所以采用此保守的方法计算newCapacity。
* 否则不再此处扩充就在put方法中进行扩充
*/
if (numKeysToBeAdded > threshold) {
int targetCapacity = (int) (numKeysToBeAdded / loadFactor + 1);
if (targetCapacity > MAXIMUM_CAPACITY)
targetCapacity = MAXIMUM_CAPACITY;
int newCapacity = table.length;
while (newCapacity < targetCapacity)
newCapacity <<= 1;
if (newCapacity > table.length)
resize(newCapacity);
}
//依次遍历添加
for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m
.entrySet().iterator(); i.hasNext();) {
Map.Entry<? extends K, ? extends V> e = i.next();
put(e.getKey(), e.getValue());
}
}
/**
* 根据知道key移除键值对，返回移除的元素
*/
public V remove(Object key) {
Entry<K, V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
/**
* 根据key移除Entry对象
*/
final Entry<K, V> removeEntryForKey(Object key) {
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
Entry<K, V> prev = table[i];
Entry<K, V> e = prev;
while (e != null) {
Entry<K, V> next = e.next;
Object k;
if (e.hash == hash
&& ((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e) //表明链表只有一个Entry对象
table[i] = next;
else
prev.next = next; //修改指针
e.recordRemoval(this); //在移除元素时调用
return e;
}
prev = e;
e = next;
}
return e;
}
/**
* 同remove方法基本相似
*/
final Entry<K, V> removeMapping(Object o) {
if (!(o instanceof Map.Entry))
return null;
Map.Entry<K, V> entry = (Map.Entry<K, V>) o;
Object key = entry.getKey();
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
Entry<K, V> prev = table[i];
Entry<K, V> e = prev;
while (e != null) {
Entry<K, V> next = e.next;
if (e.hash == hash && e.equals(entry)) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
/**
* 移除所有元素
*/
public void clear() {
modCount++;
Entry[] tab = table;
for (int i = 0; i < tab.length; i++)
tab[i] = null; //只要把数组置空即可
size = 0;
}
/**
* 是否包含次value
*/
public boolean containsValue(Object value) {
if (value == null)
return containsNullValue();
Entry[] tab = table;
for (int i = 0; i < tab.length; i++)
for (Entry e = tab[i]; e != null; e = e.next)
if (value.equals(e.value))
return true;
return false;
}
/**
* 是否包含空值
*/
private boolean containsNullValue() {
Entry[] tab = table;
for (int i = 0; i < tab.length; i++)
for (Entry e = tab[i]; e != null; e = e.next)
if (e.value == null)
return true;
return false;
}
/**
* 返回HashMap的浅拷贝实例
*/
public Object clone() {
HashMap<K, V> result = null;
try {
result = (HashMap<K, V>) super.clone();
} catch (CloneNotSupportedException e) {
// assert false;
}
result.table = new Entry[table.length];
result.entrySet = null;
result.modCount = 0;
result.size = 0;
result.init();
result.putAllForCreate(this); //依次添加本map所有元素到浅拷贝的map实例中
return result;
}
static class Entry<K, V> implements Map.Entry<K, V> {
final K key;
V value;
Entry<K, V> next;
final int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K, V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
//Entry的equals方法，键值相等即Entry对象相等
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry) o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
/**
* 重写hashCode方法，异或key与value的hashCode值
*/
public final int hashCode() {
return (key == null ? 0 : key.hashCode())
^ (value == null ? 0 : value.hashCode());
}
public final String toString() {
return getKey() + "=" + getValue();
}
/**
*
* 当添加一键值对，发现键已存在时调用此方法
* 可以继承Entry对象重写此方法
*/
void recordAccess(HashMap<K, V> m) {
}
/**
* 当有Entry对象被移除时，此方法被调用。
* 可以继承Entry对象重写此方法
*/
void recordRemoval(HashMap<K, V> m) {
}
}
/**
*
* 如果适当此方法会resize table
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K, V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K, V>(hash, key, value, e);
if (size++ >= threshold) //如果size超过threshold就调整数组容量大小为原来的两倍
resize(2 * table.length);
}
/**
*
* 与addEntry方法类似。但是方法不需要担心容量的扩充
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K, V> e = table[bucketIndex]; //如果此节点已经有一个Entry对象，返回e，否则返回null
table[bucketIndex] = new Entry<K, V>(hash, key, value, e); //以新加入的节点作为第一个节点
size++;
}
/**
* 抽象类，next方法由其子类实现，
* 不同的next方法返回不同的迭代器
* 包括key，value，keySet迭代器
* */
private abstract class HashIterator<E> implements Iterator<E> {
Entry<K, V> next; // next entry to return
int expectedModCount; // For fast-fail
int index; // current slot
Entry<K, V> current; // current entry
HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
//遍历直到获取第一个Entry对象，因为有的索引可能为空
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
/**
* 返回下一个Entry对象
* */
final Entry<K, V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K, V> e = next;
if (e == null)
throw new NoSuchElementException();
if ((next = e.next) == null) {
Entry[] t = table;
//继续找不为空的索引中的Entry对象
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
/**
* 移除当前Entry对象，即调用nextEntry返回的Entry对象
*/
public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Object k = current.key;
current = null;
HashMap.this.removeEntryForKey(k); //此方法会改变modCount
expectedModCount = modCount; //所以可以用此语句检测是否产生了并发操作
}
}
//依次重写next方法，返回不同的迭代器。
private final class ValueIterator extends HashIterator<V> {
public V next() {
return nextEntry().value;
}
}
private final class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}
private final class EntryIterator extends HashIterator<Map.Entry<K, V>> {
public Map.Entry<K, V> next() {
return nextEntry();
}
}
// Subclass overrides these to alter behavior of views' iterator() method
Iterator<K> newKeyIterator() {
return new KeyIterator();
}
Iterator<V> newValueIterator() {
return new ValueIterator();
}
Iterator<Map.Entry<K, V>> newEntryIterator() {
return new EntryIterator();
}
// Views
private transient Set<Map.Entry<K, V>> entrySet = null;
/**
* 返回一个key集。
* 此Set集合只在第一次调用keySet()时被创建，此后返回的都是同一个Set。
* 此方法不是线程安全的，大量线程多次调用此方法返回的可能不是同一个Set（可能是重新new的）
*
* 对map的修改会反应到Set当中，相反，对Set中key进行移除操作，比如
* Iterator.remove,Set.remove ,removeAll,retainAll,clear等操作时被移除的键
* 和它相关联的值也将从map中被移除，但是此Set不支持任何添加操作
*/
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}
private final class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsKey(o);
}
/**
* 重写了Set的remove方法，
* 父类remove都是调用迭代器的remove方法
* */
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}
/**
* 同上
*/
public Collection<V> values() {
Collection<V> vs = values;
return (vs != null ? vs : (values = new Values()));
}
private final class Values extends AbstractCollection<V> {
public Iterator<V> iterator() {
return newValueIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsValue(o);
}
public void clear() {
HashMap.this.clear();
}
}
/**
* 同上
*/
public Set<Map.Entry<K, V>> entrySet() {
return entrySet0();
}
private Set<Map.Entry<K, V>> entrySet0() {
Set<Map.Entry<K, V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
private final class EntrySet extends AbstractSet<Map.Entry<K, V>> {
public Iterator<Map.Entry<K, V>> iterator() {
return newEntryIterator();
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<K, V> e = (Map.Entry<K, V>) o;
Entry<K, V> candidate = getEntry(e.getKey());
return candidate != null && candidate.equals(e);
}
public boolean remove(Object o) {
return removeMapping(o) != null;
}
public int size() {
return size;
}
public void clear() {
HashMap.this.clear();
}
}
/**
* 序列化hashMap对象
*/
private void writeObject(java.io.ObjectOutputStream s) throws IOException {
Iterator<Map.Entry<K, V>> i = (size > 0) ? entrySet0().iterator()
: null;
// 写入默认信息
s.defaultWriteObject();
// 写入可以存储的容量
s.writeInt(table.length);
// 写入实际长度
s.writeInt(size);
// Write out keys and values (alternating)
if (i != null) {
while (i.hasNext()) { //依次写入键值对
Map.Entry<K, V> e = i.next();
s.writeObject(e.getKey());
s.writeObject(e.getValue());
}
}
}
private static final long serialVersionUID = 362498820763181265L;
/**
* 读出HashMap对象
*/
private void readObject(java.io.ObjectInputStream s) throws IOException,
ClassNotFoundException {
//读出默认信息
s.defaultReadObject();
// 读容量
int numBuckets = s.readInt();
table = new Entry[numBuckets];
init(); // Give subclass a chance to do its thing.
// 读长度
int size = s.readInt();
//读键值对，并还原HashMap元素
for (int i = 0; i < size; i++) {
K key = (K) s.readObject();
V value = (V) s.readObject();
putForCreate(key, value);
}
}
// These methods are used when serializing HashSets
int capacity() {
return table.length;
}
float loadFactor() {
return loadFactor;
}
}
（四）HashSet
/**
* 散列集（hashSet）,就是不存在重复元素的集合。
* HashSet是在HashMap的基础上实现的，
* 以HashSet的元素做Key值使其值不会重复
* */
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable,
java.io.Serializable {
static final long serialVersionUID = -5024744406713321676L;
private transient HashMap<E, Object> map;
//以Object作为虚假的Value值
private static final Object PRESENT = new Object();
/**
*
* 构造一个新的，空Set集；
* 实际是构造一个默认初始容量为16，加载因子为0.75的空HashMap
*/
public HashSet() {
map = new HashMap<E, Object>();
}
/**
*
* 构造一个包含指定集合c中所有元素的新的Set集。
* 实际是构造包含集合c中所有元素的HashMap.
* 初始大小必须大于容量*0.75
*
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<E, Object>(Math.max((int) (c.size() / .75f) + 1, 16));
addAll(c);
}
/**
* 以指定初始容量和加载因子构造HashMap
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<E, Object>(initialCapacity, loadFactor);
}
/**
* 以初始容量构造HashMap
*/
public HashSet(int initialCapacity) {
map = new HashMap<E, Object>(initialCapacity);
}
/**
*
* 构造一个Linked hash set.
* 以指定初始容量，加载因子构造LinkedHashMap，dummy只是为了区别其他构造方法
*
*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<E, Object>(initialCapacity, loadFactor);
}
/**
* 获得HashMap的键集迭代器
*/
public Iterator<E> iterator() {
return map.keySet().iterator();
}
/**
* 返回元素个数
*/
public int size() {
return map.size();
}
/**
* 判断Hash集是否为空
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* 如果Map中含有此key则返回true
*/
public boolean contains(Object o) {
return map.containsKey(o);
}
/**
*
* 如果e不存在于Set中则添加e到集合，
* 如果Map中key集不存在e，则添加并返回null，否则替换原来的value，返回oldValue
*
*/
public boolean add(E e) {
return map.put(e, PRESENT) == null;
}
/**
* 移除指定元素
*/
public boolean remove(Object o) {
return map.remove(o) == PRESENT;
}
/**
* 清空map
*/
public void clear() {
map.clear();
}
/**
* 返回HashSet的浅拷贝对象
*/
public Object clone() {
try {
HashSet<E> newSet = (HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
//写入HashMap的容量和加载系数
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
//写入size
s.writeInt(map.size());
//依次写入键值
for (Iterator i = map.keySet().iterator(); i.hasNext();)
s.writeObject(i.next());
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
//读取容量和加载因子构造HashMap
int capacity = s.readInt();
float loadFactor = s.readFloat();
//判断是LinkedHashMap还是HashMap
map = (((HashSet) this) instanceof LinkedHashSet ? new LinkedHashMap<E, Object>(
capacity, loadFactor)
: new HashMap<E, Object>(capacity, loadFactor));
// 读size
int size = s.readInt();
//依次读出所有元素
for (int i = 0; i < size; i++) {
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
}
892
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
