Java数据结构Vetor
Java数据结构Vector
/**
* <html>
* <body>
* <P> Copyright JasonInternational</p>
* <p> All rights reserved.</p>
* <p> Created on 2018年6月29日 上午9:00:48</p>
* <p> Created by Jason </p>
* </body>
* </html>
*/
package cn.ucaner.sourceanalysis.list; import java.util.AbstractList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collection;
import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.RandomAccess;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator; /**
* @Package：cn.ucaner.sourceanalysis
* @ClassName：Vector
* @Description： <p> Vector Vector 可实现自动增长的对象数组</p>
* @Author： - Jason
* @CreatTime：2018年6月29日 上午9:00:48
* @Modify By：
* @ModifyTime： 2018年6月29日
* @Modify marker：
* @version V1.0
*/ /****************Notice******************
[参考]{@link https://www.cnblogs.com/zheting/p/7708366.html} {@link https://www.cnblogs.com/skywang12345/p/3308833.html} Vector 是矢量队列，它是JDK1.0版本添加的类。继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口 Vector 继承了AbstractList,实现了List;所以，它是一个队列,支持相关的添加、删除、修改、遍历等功能.
Vector 实现了RandmoAccess接口,即提供了随机访问功能.
RandmoAccess是Java中用来被List实现,为List提供快速访问功能的.
在Vector中，我们即可以通过元素的序号快速获取元素对象;这就是快速随机访问。 Vector 实现了Cloneable接口,即实现clone()函数,它能被克隆,与ArrayList不同，Vector中的操作是线程安全的. Vector共有4个构造函数 Vector()// 默认构造函数 Vector(int capacity)// capacity是Vector的默认容量大小。当由于增加数据导致容量增加时，每次容量会增加一倍。 Vector(int capacity, int capacityIncrement)// capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。 Vector(Collection<? extends E> collection)// 创建一个包含collection的Vector *******************End**************************/
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ private static final long serialVersionUID = 2411957469099220630L; /**
* 元素数据 - elementData是个动态数组，如果初始化Vector时，没指定动态数组的>大小，则使用默认大小10
*/
protected Object[] elementData; /**
* 元素个数 - elementCount 是动态数组的实际大小
*/
protected int elementCount; /**
* 容量增长 - 每次Vector容量增加时的增量值 - 如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时>，增加的大小都是capacityIncrement
*/
protected int capacityIncrement; /**
* Vector. 构造函数
* @param initialCapacity 容量大小
* @param capacityIncrement 扩容因子
*/
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("[Java-Core-Advanced]Illegal Capacity: "+initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
} /**
* Vector.
* @param initialCapacity 容量大小
*/
public Vector(int initialCapacity) {
this(initialCapacity, 0);//扩容因子为0
} /**
* Vector. 默认为10
*/
public Vector() {
this(10);
} /**
* Vector.
* @param c Collection
*/
public Vector(Collection<? extends E> c) {
elementData = c.toArray();
elementCount = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class) {
elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}
} /**
* @Description: copyInto
* @param anArray void
* @Autor: Jason
*/
public synchronized void copyInto(Object[] anArray) {
System.arraycopy(elementData, 0, anArray, 0, elementCount);
} /**
* @Description: trimToSize
* @Autor: Jason
*/
public synchronized void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (elementCount < oldCapacity) {
elementData = Arrays.copyOf(elementData, elementCount);
}
} /**
* @Description: ensureCapacity
* @param minCapacity
* @Autor: Jason
*/
public synchronized void ensureCapacity(int minCapacity) {
if (minCapacity > 0) {
modCount++;
ensureCapacityHelper(minCapacity);
}
} /**
* @Description: ensureCapacityHelper
* @param minCapacity
* @Autor: Jason
*/
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
} /**
* 最大数组大小
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; /**
* @Description: grow
* @param minCapacity
* @Autor: Jason
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
} /**
* @Description: hugeCapacity
* @param minCapacity
* @return int
* @Autor: Jason
*/
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
} /**
* @Description: setSize
* @param newSize void
* @Autor: Jason
*/
public synchronized void setSize(int newSize) {
modCount++;
if (newSize > elementCount) {
ensureCapacityHelper(newSize);
} else {
for (int i = newSize ; i < elementCount ; i++) {
elementData[i] = null;
}
}
elementCount = newSize;
} /**
* @Description: 返回当前容器的大小
* @return int
* @Autor: Jason
*/
public synchronized int capacity() {
return elementData.length;
} /**
* 返回当前数据统计
*/
public synchronized int size() {
return elementCount;
} /**
* 是否为空
*/
public synchronized boolean isEmpty() {
return elementCount == 0;
} /**
* @Description: 元素枚举
* @return Enumeration<E>
* @Autor: Jason
*/
public Enumeration<E> elements() {
return new Enumeration<E>() {
int count = 0; public boolean hasMoreElements() {
return count < elementCount;
} public E nextElement() {
synchronized (Vector.this) {
if (count < elementCount) {
return elementData(count++);
}
}
throw new NoSuchElementException("Vector Enumeration");
}
};
} /**
* 是否包含
*/
public boolean contains(Object o) {
return indexOf(o, 0) >= 0;
} /**
* 元素的索引位置
*/
public int indexOf(Object o) {
return indexOf(o, 0);
} /**
* @Description: indexOf
* @param o
* @param index
* @return int
* @Autor: Jason
*/
public synchronized int indexOf(Object o, int index) {
if (o == null) {
for (int i = index ; i < elementCount ; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = index ; i < elementCount ; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
} /**
* lastIndexOf
*/
public synchronized int lastIndexOf(Object o) {
return lastIndexOf(o, elementCount-1);
} /**
* @Description: lastIndexOf
* @param o
* @param index
* @return int
* @Autor: Jason
*/
public synchronized int lastIndexOf(Object o, int index) {
if (index >= elementCount)
throw new IndexOutOfBoundsException(index + " >= "+ elementCount); if (o == null) {
for (int i = index; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = index; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
} /**
* @Description: elementAt
* @param index
* @return E
* @Autor: Jason
*/
public synchronized E elementAt(int index) {
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
} return elementData(index);
} /**
* @Description: Returns the first component
* @return E
* @Autor: Jason
*/
public synchronized E firstElement() {
if (elementCount == 0) {
throw new NoSuchElementException();
}
return elementData(0);
} /**
* @Description: 返回容器里最后一个元素
* @return E
* @Autor: Jason
*/
public synchronized E lastElement() {
if (elementCount == 0) {
throw new NoSuchElementException();
}
return elementData(elementCount - 1);
} /**
* @Description: 设置元素
* @param obj
* @param index void
* @Autor: Jason
*/
public synchronized void setElementAt(E obj, int index) {
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}
elementData[index] = obj;
} /**
* @Description: 移除指定位置的元素
* @param index 索引位置
* @Autor: Jason
*/
public synchronized void removeElementAt(int index) {
modCount++;
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}
else if (index < 0) {
throw new ArrayIndexOutOfBoundsException(index);
}
int j = elementCount - index - 1;
if (j > 0) {
System.arraycopy(elementData, index + 1, elementData, index, j);
}
elementCount--;
elementData[elementCount] = null; /* to let gc do its work */
} /**
* @Description: 插入数据到具体的索引位置
* @param obj
* @param index 索引位置
* @Autor: Jason
*/
public synchronized void insertElementAt(E obj, int index) {
modCount++;
if (index > elementCount) {
throw new ArrayIndexOutOfBoundsException(index
+ " > " + elementCount);
}
ensureCapacityHelper(elementCount + 1);
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
elementData[index] = obj;
elementCount++;
} /**
* @Description: 添加元素 - Core 基本可以看出来Vector的数结构
* @param obj 元素
* @Autor: Jason
*/
public synchronized void addElement(E obj) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
} /**
* @Description: 移除指定Object元素的数据
* @param obj
* @return boolean
* @Autor: Jason
*/
public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj);
if (i >= 0) {
removeElementAt(i);
return true;
}
return false;
} /**
* @Description:移除所有的元素
* @Autor: Jason
*/
public synchronized void removeAllElements() {
modCount++;
// Let gc do its work
for (int i = 0; i < elementCount; i++)
elementData[i] = null; //循环置空 gc垃圾回收机制处理 elementCount = 0;
} /**
* 克隆接口 实现克隆
*/
public synchronized Object clone() {
try {
@SuppressWarnings("unchecked")
Vector<E> v = (Vector<E>) super.clone();
v.elementData = Arrays.copyOf(elementData, elementCount);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
} /**
* toArray
*/
public synchronized Object[] toArray() {
return Arrays.copyOf(elementData, elementCount);
} /**
* toArray
*/
@SuppressWarnings("unchecked")
public synchronized <T> T[] toArray(T[] a) {
if (a.length < elementCount)
return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass()); System.arraycopy(elementData, 0, a, 0, elementCount); if (a.length > elementCount) {
a[elementCount] = null;
}
return a;
} // Positional Access Operations
/**
* @Description: elementData
* @param index
* @return E
* @Autor: Jason
*/
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
} /**
* get by Index
*/
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
} /**
* set data into Index Vector
*/
public synchronized E set(int index, E element) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index); E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
} /**
* 添加数据到后面
*/
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
} /**
* 移除元素
*/
public boolean remove(Object o) {
return removeElement(o);
} /**
* 添加元素
*/
public void add(int index, E element) {
insertElementAt(element, index);
} /**
* 移除置空 垃圾回收机制做处理
*/
public synchronized E remove(int index) {
modCount++;
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index); int numMoved = elementCount - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,numMoved);
elementData[--elementCount] = null; // Let gc do its work return oldValue;
} /**
* 清空
*/
public void clear() {
removeAllElements();
} // Bulk Operations
/**
* Collection 循环比较所有是不是 contains(e)
*/
public synchronized boolean containsAll(Collection<?> c) {
return super.containsAll(c);
} /**
* 添加整个集合
*/
public synchronized boolean addAll(Collection<? extends E> c) {
modCount++;
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityHelper(elementCount + numNew);
System.arraycopy(a, 0, elementData, elementCount, numNew);
elementCount += numNew;
return numNew != 0;
} /**
* 移除所有
*/
public synchronized boolean removeAll(Collection<?> c) {
return super.removeAll(c);
} /**
* retainAll 包含所有
*/
public synchronized boolean retainAll(Collection<?> c) {
return super.retainAll(c);
} /**
* addAll Collection
*/
public synchronized boolean addAll(int index, Collection<? extends E> c) {
modCount++;
if (index < 0 || index > elementCount) {//索引越界异常
throw new ArrayIndexOutOfBoundsException(index);
}
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityHelper(elementCount + numNew);
int numMoved = elementCount - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,numMoved); System.arraycopy(a, 0, elementData, index, numNew);
elementCount += numNew;
return numNew != 0;
} /**
* equals
*/
public synchronized boolean equals(Object o) {
return super.equals(o);
} /**
* hashCode = 31*hashCode + (e==null ? 0 : e.hashCode()); 抽象类的HashCode方法 没有重写
*/
public synchronized int hashCode() {
return super.hashCode();
} /**
* 抽象集合的toString方法
*/
public synchronized String toString() {
return super.toString();
} /**
* Returns a view of the portion of this List between fromIndex,
* inclusive, and toIndex, exclusive. (If fromIndex and toIndex are
* equal, the returned List is empty.) The returned List is backed by this
* List, so changes in the returned List are reflected in this List, and
* vice-versa. The returned List supports all of the optional List
* operations supported by this List.
*
* <p>This method eliminates the need for explicit range operations (of
* the sort that commonly exist for arrays). Any operation that expects
* a List can be used as a range operation by operating on a subList view
* instead of a whole List. For example, the following idiom
* removes a range of elements from a List:
* <pre>
* list.subList(from, to).clear();
* </pre>
* Similar idioms may be constructed for indexOf and lastIndexOf,
* and all of the algorithms in the Collections class can be applied to
* a subList.
*
* <p>The semantics of the List returned by this method become undefined if
* the backing list (i.e., this List) is <i>structurally modified</i> in
* any way other than via the returned List. (Structural modifications are
* those that change the size of the List, or otherwise perturb it in such
* a fashion that iterations in progress may yield incorrect results.)
*
* @param fromIndex low endpoint (inclusive) of the subList
* @param toIndex high endpoint (exclusive) of the subList
* @return a view of the specified range within this List
* @throws IndexOutOfBoundsException if an endpoint index value is out of range
* {@code (fromIndex < 0 || toIndex > size)}
* @throws IllegalArgumentException if the endpoint indices are out of order
* {@code (fromIndex > toIndex)}
*/
/*public synchronized List<E> subList(int fromIndex, int toIndex) {
return Collections.synchronizedList(super.subList(fromIndex, toIndex),this);
}*/ /**
* 移除范围
*/
protected synchronized void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = elementCount - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved);
// Let gc do its work
int newElementCount = elementCount - (toIndex-fromIndex);
while (elementCount != newElementCount)
elementData[--elementCount] = null;
} /**
* Save the state of the {@code Vector} instance to a stream (that
* is, serialize it).
* This method performs synchronization to ensure the consistency
* of the serialized data.
*/
/**
* @Description: writeObject
* @param s
* @throws java.io.IOException
* @Autor: Jason
*/
private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException {
final java.io.ObjectOutputStream.PutField fields = s.putFields();
final Object[] data;
synchronized (this) {
fields.put("capacityIncrement", capacityIncrement);
fields.put("elementCount", elementCount);
data = elementData.clone();
}
fields.put("elementData", data);
s.writeFields();
} /**
* List 迭代器
*/
public synchronized ListIterator<E> listIterator(int index) {
if (index < 0 || index > elementCount)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
} /**
* Returns a list iterator over the elements in this list (in proper sequence).
*/
public synchronized ListIterator<E> listIterator() {
return new ListItr(0);
} /**
* Returns an iterator over the elements in this list in proper sequence.
*/
public synchronized Iterator<E> iterator() {
return new Itr();
} /**
* @Package：cn.ucaner.sourceanalysis
* @ClassName：Itr
* @Description： <p> An optimized version of AbstractList.Itr 实现迭代器</p>
* @Author： - Jason
* @Modify By：
* @Modify marker：
* @version V1.0
*/
private class Itr implements Iterator<E> { int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount; public boolean hasNext() {
// Racy but within spec, since modifications are checked
// within or after synchronization in next/previous
return cursor != elementCount;
} public E next() {
synchronized (Vector.this) {
checkForComodification();
int i = cursor;
if (i >= elementCount)
throw new NoSuchElementException();
cursor = i + 1;
return elementData(lastRet = i);
}
} public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
synchronized (Vector.this) {
checkForComodification();
Vector.this.remove(lastRet);
expectedModCount = modCount;
}
cursor = lastRet;
lastRet = -1;
} @Override
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
synchronized (Vector.this) {
final int size = elementCount;
int i = cursor;
if (i >= size) {
return;
}
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) Vector.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
action.accept(elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
} final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
} /**
* @Package：cn.ucaner.sourceanalysis
* @ClassName：ListItr
* @Description： <p> An optimized version of AbstractList.ListItr </p>
* @Author： - Jason
* @Modify By：
* @Modify marker：
* @version V1.0
*/
final class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
} public boolean hasPrevious() {
return cursor != 0;
} public int nextIndex() {
return cursor;
} public int previousIndex() {
return cursor - 1;
} public E previous() {
synchronized (Vector.this) {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
cursor = i;
return elementData(lastRet = i);
}
} public void set(E e) {
if (lastRet == -1)
throw new IllegalStateException();
synchronized (Vector.this) {
checkForComodification();
Vector.this.set(lastRet, e);
}
} public void add(E e) {
int i = cursor;
synchronized (Vector.this) {
checkForComodification();
Vector.this.add(i, e);
expectedModCount = modCount;
}
cursor = i + 1;
lastRet = -1;
}
} /**
* forEach 增强for循环
*/
@Override
public synchronized void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);
final int expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) this.elementData;
final int elementCount = this.elementCount;
for (int i=0; modCount == expectedModCount && i < elementCount; i++) {
action.accept(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
} /**
* removeIf
*/
@Override
@SuppressWarnings("unchecked")
public synchronized 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 int size = elementCount;
final BitSet removeSet = new BitSet(size);
final int expectedModCount = modCount;
for (int i=0; modCount == expectedModCount && i < size; i++) {
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
}
elementCount = newSize;
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
} return anyToRemove;
} /**
* 替换
*/
@Override
@SuppressWarnings("unchecked")
public synchronized void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final int expectedModCount = modCount;
final int size = elementCount;
for (int i=0; modCount == expectedModCount && i < size; i++) {
elementData[i] = operator.apply((E) elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
} /**
* 排序
*/
@SuppressWarnings("unchecked")
@Override
public synchronized void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
Arrays.sort((E[]) elementData, 0, elementCount, c);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
} /**
* 分隔符
*/
@Override
public Spliterator<E> spliterator() {
return new VectorSpliterator<>(this, null, 0, -1, 0);
} /**
* @Package：cn.ucaner.sourceanalysis
* @ClassName：VectorSpliterator
* @Description： <p> Similar to ArrayList Spliterator </p>
* @Author： - Jason
* @Modify By：
* @Modify marker：
* @version V1.0
*/
static final class VectorSpliterator<E> implements Spliterator<E> {
private final Vector<E> list;
private Object[] array;
private int index; // current index, modified on advance/split
private int fence; // -1 until used; then one past last index
private int expectedModCount; // initialized when fence set /**
* VectorSpliterator. Create new spliterator covering the given range
* @param list
* @param array
* @param origin
* @param fence
* @param expectedModCount
*/
VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence,
int expectedModCount) {
this.list = list;
this.array = array;
this.index = origin;
this.fence = fence;
this.expectedModCount = expectedModCount;
} private int getFence() { // initialize on first use
int hi;
if ((hi = fence) < 0) {
synchronized(list) {
array = list.elementData;
expectedModCount = list.modCount;
hi = fence = list.elementCount;
}
}
return hi;
} public Spliterator<E> trySplit() {
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
return (lo >= mid) ? null :
new VectorSpliterator<E>(list, array, lo, index = mid,
expectedModCount);
} @SuppressWarnings("unchecked")
public boolean tryAdvance(Consumer<? super E> action) {
int i;
if (action == null)
throw new NullPointerException();
if (getFence() > (i = index)) {
index = i + 1;
action.accept((E)array[i]);
if (list.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
return false;
} @SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> action) {
int i, hi; // hoist accesses and checks from loop
Vector<E> lst; Object[] a;
if (action == null)
throw new NullPointerException();
if ((lst = list) != null) {
if ((hi = fence) < 0) {
synchronized(lst) {
expectedModCount = lst.modCount;
a = array = lst.elementData;
hi = fence = lst.elementCount;
}
}
else
a = array;
if (a != null && (i = index) >= 0 && (index = hi) <= a.length) {
while (i < hi)
action.accept((E) a[i++]);
if (lst.modCount == expectedModCount)
return;
}
}
throw new ConcurrentModificationException();
} public long estimateSize() {
return (long) (getFence() - index);
} public int characteristics() {
return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
}
}
}
/** * <html> * <body> * <P> Copyright JasonInternational</p> * <p> All rights reserved.</p> * <p> Created on 2018年6月29日 上午9:00:48</p> * <p> Created by Jason </p> * </body> * </html> */package cn.ucaner.sourceanalysis.list;
import java.util.AbstractList;import java.util.Arrays;import java.util.BitSet;import java.util.Collection;import java.util.Comparator;import java.util.ConcurrentModificationException;import java.util.Enumeration;import java.util.Iterator;import java.util.List;import java.util.ListIterator;import java.util.NoSuchElementException;import java.util.Objects;import java.util.RandomAccess;import java.util.Spliterator;import java.util.function.Consumer;import java.util.function.Predicate;import java.util.function.UnaryOperator;
/** * @Package：cn.ucaner.sourceanalysis * @ClassName：Vector * @Description： <p> Vector Vector 可实现自动增长的对象数组</p>* @Author： - Jason * @CreatTime：2018年6月29日 上午9:00:48 * @Modify By： * @ModifyTime： 2018年6月29日* @Modify marker： * @version V1.0*/
/****************Notice******************[参考]{@link https://www.cnblogs.com/zheting/p/7708366.html} {@link https://www.cnblogs.com/skywang12345/p/3308833.html}
Vector 是矢量队列，它是JDK1.0版本添加的类。继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口
Vector 继承了AbstractList,实现了List;所以，它是一个队列,支持相关的添加、删除、修改、遍历等功能.Vector 实现了RandmoAccess接口,即提供了随机访问功能.RandmoAccess是Java中用来被List实现,为List提供快速访问功能的.在Vector中，我们即可以通过元素的序号快速获取元素对象;这就是快速随机访问。
Vector 实现了Cloneable接口,即实现clone()函数,它能被克隆,与ArrayList不同，Vector中的操作是线程安全的.
Vector共有4个构造函数Vector()// 默认构造函数Vector(int capacity)// capacity是Vector的默认容量大小。当由于增加数据导致容量增加时，每次容量会增加一倍。Vector(int capacity, int capacityIncrement)// capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。Vector(Collection<? extends E> collection)// 创建一个包含collection的Vector
*******************End**************************/public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
private static final long serialVersionUID = 2411957469099220630L;/** * 元素数据 - elementData是个动态数组，如果初始化Vector时，没指定动态数组的>大小，则使用默认大小10 */protected Object[] elementData;/** * 元素个数 - elementCount 是动态数组的实际大小 */protected int elementCount;
/** * 容量增长 - 每次Vector容量增加时的增量值 - 如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时>，增加的大小都是capacityIncrement */protected int capacityIncrement;/*** Vector. 构造函数* @param initialCapacity 容量大小* @param capacityIncrement 扩容因子 */public Vector(int initialCapacity, int capacityIncrement) { super(); if (initialCapacity < 0) throw new IllegalArgumentException("[Java-Core-Advanced]Illegal Capacity: "+initialCapacity); this.elementData = new Object[initialCapacity]; this.capacityIncrement = capacityIncrement; }/*** Vector. * @param initialCapacity 容量大小 */public Vector(int initialCapacity) { this(initialCapacity, 0);//扩容因子为0 }/*** Vector. 默认为10 */public Vector() { this(10); }/*** Vector. * @param c Collection */public Vector(Collection<? extends E> c) { elementData = c.toArray(); elementCount = elementData.length; // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) { elementData = Arrays.copyOf(elementData, elementCount, Object[].class); } }/** * @Description: copyInto * @param anArray void * @Autor: Jason */public synchronized void copyInto(Object[] anArray) { System.arraycopy(elementData, 0, anArray, 0, elementCount); }/** * @Description: trimToSize * @Autor: Jason */public synchronized void trimToSize() { modCount++; int oldCapacity = elementData.length; if (elementCount < oldCapacity) { elementData = Arrays.copyOf(elementData, elementCount); } }/** * @Description: ensureCapacity * @param minCapacity * @Autor: Jason */public synchronized void ensureCapacity(int minCapacity) { if (minCapacity > 0) { modCount++; ensureCapacityHelper(minCapacity); } }/** * @Description: ensureCapacityHelper * @param minCapacity * @Autor: Jason */private void ensureCapacityHelper(int minCapacity) { // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }
/** * 最大数组大小 */ private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/** * @Description: grow * @param minCapacity * @Autor: Jason */private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length;int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);if (newCapacity - minCapacity < 0) newCapacity = minCapacity;if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity);elementData = Arrays.copyOf(elementData, newCapacity);}
/** * @Description: hugeCapacity * @param minCapacity * @return int * @Autor: Jason */private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;}
/** * @Description: setSize * @param newSize void * @Autor: Jason */public synchronized void setSize(int newSize) { modCount++; if (newSize > elementCount) { ensureCapacityHelper(newSize); } else { for (int i = newSize ; i < elementCount ; i++) { elementData[i] = null; } } elementCount = newSize;}
/** * @Description: 返回当前容器的大小 * @return int * @Autor: Jason */ public synchronized int capacity() { return elementData.length; }
/** * 返回当前数据统计 */ public synchronized int size() { return elementCount; }
/** * 是否为空 */public synchronized boolean isEmpty() { return elementCount == 0;}
/** * @Description: 元素枚举 * @return Enumeration<E> * @Autor: Jason */public Enumeration<E> elements() { return new Enumeration<E>() { int count = 0; public boolean hasMoreElements() { return count < elementCount; } public E nextElement() { synchronized (Vector.this) { if (count < elementCount) { return elementData(count++); } } throw new NoSuchElementException("Vector Enumeration"); } };}
/** * 是否包含 */public boolean contains(Object o) { return indexOf(o, 0) >= 0;}
/** * 元素的索引位置 */ public int indexOf(Object o) { return indexOf(o, 0); }
/** * @Description: indexOf * @param o * @param index * @return int * @Autor: Jason */public synchronized int indexOf(Object o, int index) { if (o == null) { for (int i = index ; i < elementCount ; i++) if (elementData[i]==null) return i; } else { for (int i = index ; i < elementCount ; i++) if (o.equals(elementData[i])) return i; } return -1;}
/** * lastIndexOf */ public synchronized int lastIndexOf(Object o) { return lastIndexOf(o, elementCount-1); }
/** * @Description: lastIndexOf * @param o * @param index * @return int * @Autor: Jason */ public synchronized int lastIndexOf(Object o, int index) { if (index >= elementCount) throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
if (o == null) { for (int i = index; i >= 0; i--) if (elementData[i]==null) return i; } else { for (int i = index; i >= 0; i--) if (o.equals(elementData[i])) return i; } return -1; }
/** * @Description: elementAt * @param index * @return E * @Autor: Jason */ public synchronized E elementAt(int index) { if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); }
return elementData(index); }
/** * @Description: Returns the first component * @return E * @Autor: Jason */public synchronized E firstElement() { if (elementCount == 0) { throw new NoSuchElementException(); } return elementData(0);}
/** * @Description: 返回容器里最后一个元素 * @return E * @Autor: Jason */ public synchronized E lastElement() { if (elementCount == 0) { throw new NoSuchElementException(); } return elementData(elementCount - 1); }
/** * @Description: 设置元素 * @param obj * @param index void * @Autor: Jason */ public synchronized void setElementAt(E obj, int index) { if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); } elementData[index] = obj; }
/** * @Description: 移除指定位置的元素 * @param index 索引位置 * @Autor: Jason */ public synchronized void removeElementAt(int index) { modCount++; if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); } else if (index < 0) { throw new ArrayIndexOutOfBoundsException(index); } int j = elementCount - index - 1; if (j > 0) { System.arraycopy(elementData, index + 1, elementData, index, j); } elementCount--; elementData[elementCount] = null; /* to let gc do its work */ }
/** * @Description: 插入数据到具体的索引位置 * @param obj * @param index 索引位置 * @Autor: Jason */ public synchronized void insertElementAt(E obj, int index) { modCount++; if (index > elementCount) { throw new ArrayIndexOutOfBoundsException(index + " > " + elementCount); } ensureCapacityHelper(elementCount + 1); System.arraycopy(elementData, index, elementData, index + 1, elementCount - index); elementData[index] = obj; elementCount++; }
/** * @Description: 添加元素 - Core 基本可以看出来Vector的数结构 * @param obj 元素 * @Autor: Jason */ public synchronized void addElement(E obj) { modCount++; ensureCapacityHelper(elementCount + 1); elementData[elementCount++] = obj; }
/** * @Description: 移除指定Object元素的数据 * @param obj * @return boolean * @Autor: Jason */public synchronized boolean removeElement(Object obj) { modCount++; int i = indexOf(obj); if (i >= 0) { removeElementAt(i); return true; } return false;}
/** * @Description:移除所有的元素 * @Autor: Jason */public synchronized void removeAllElements() { modCount++; // Let gc do its work for (int i = 0; i < elementCount; i++) elementData[i] = null; //循环置空 gc垃圾回收机制处理 elementCount = 0;}
/** * 克隆接口 实现克隆 */ public synchronized Object clone() { try { @SuppressWarnings("unchecked") Vector<E> v = (Vector<E>) super.clone(); v.elementData = Arrays.copyOf(elementData, elementCount); v.modCount = 0; return v; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(e); } }
/** * toArray */ public synchronized Object[] toArray() { return Arrays.copyOf(elementData, elementCount); }
/** * toArray */@SuppressWarnings("unchecked")public synchronized <T> T[] toArray(T[] a) { if (a.length < elementCount) return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass()); System.arraycopy(elementData, 0, a, 0, elementCount); if (a.length > elementCount) { a[elementCount] = null; } return a;}
// Positional Access Operations/** * @Description: elementData * @param index * @return E * @Autor: Jason */ @SuppressWarnings("unchecked") E elementData(int index) { return (E) elementData[index]; }
/** * get by Index */ public synchronized E get(int index) { if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); return elementData(index); }
/** * set data into Index Vector */ public synchronized E set(int index, E element) { if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index); elementData[index] = element; return oldValue; } /** * 添加数据到后面 */ public synchronized boolean add(E e) { modCount++; ensureCapacityHelper(elementCount + 1); elementData[elementCount++] = e; return true; }
/** * 移除元素 */ public boolean remove(Object o) { return removeElement(o); }
/** * 添加元素 */ public void add(int index, E element) { insertElementAt(element, index); }
/** * 移除置空 垃圾回收机制做处理 */ public synchronized E remove(int index) { modCount++; if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); E oldValue = elementData(index);
int numMoved = elementCount - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index,numMoved); elementData[--elementCount] = null; // Let gc do its work
return oldValue; }
/** * 清空 */ public void clear() { removeAllElements(); }
// Bulk Operations /** * Collection 循环比较所有是不是 contains(e) */ public synchronized boolean containsAll(Collection<?> c) { return super.containsAll(c); }
/** * 添加整个集合 */ public synchronized boolean addAll(Collection<? extends E> c) { modCount++; Object[] a = c.toArray(); int numNew = a.length; ensureCapacityHelper(elementCount + numNew); System.arraycopy(a, 0, elementData, elementCount, numNew); elementCount += numNew; return numNew != 0; }
/** * 移除所有 */ public synchronized boolean removeAll(Collection<?> c) { return super.removeAll(c); }
/** * retainAll 包含所有 */ public synchronized boolean retainAll(Collection<?> c) { return super.retainAll(c); }
/** * addAll Collection */ public synchronized boolean addAll(int index, Collection<? extends E> c) { modCount++; if (index < 0 || index > elementCount) {//索引越界异常 throw new ArrayIndexOutOfBoundsException(index); } Object[] a = c.toArray(); int numNew = a.length; ensureCapacityHelper(elementCount + numNew); int numMoved = elementCount - index; if (numMoved > 0) System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
System.arraycopy(a, 0, elementData, index, numNew); elementCount += numNew; return numNew != 0; }
/** * equals */ public synchronized boolean equals(Object o) { return super.equals(o); }
/** * hashCode = 31*hashCode + (e==null ? 0 : e.hashCode()); 抽象类的HashCode方法 没有重写 */ public synchronized int hashCode() { return super.hashCode(); }
/** * 抽象集合的toString方法 */ public synchronized String toString() { return super.toString(); }
/** * Returns a view of the portion of this List between fromIndex, * inclusive, and toIndex, exclusive. (If fromIndex and toIndex are * equal, the returned List is empty.) The returned List is backed by this * List, so changes in the returned List are reflected in this List, and * vice-versa. The returned List supports all of the optional List * operations supported by this List. * * <p>This method eliminates the need for explicit range operations (of * the sort that commonly exist for arrays). Any operation that expects * a List can be used as a range operation by operating on a subList view * instead of a whole List. For example, the following idiom * removes a range of elements from a List: * <pre> * list.subList(from, to).clear(); * </pre> * Similar idioms may be constructed for indexOf and lastIndexOf, * and all of the algorithms in the Collections class can be applied to * a subList. * * <p>The semantics of the List returned by this method become undefined if * the backing list (i.e., this List) is <i>structurally modified</i> in * any way other than via the returned List. (Structural modifications are * those that change the size of the List, or otherwise perturb it in such * a fashion that iterations in progress may yield incorrect results.) * * @param fromIndex low endpoint (inclusive) of the subList * @param toIndex high endpoint (exclusive) of the subList * @return a view of the specified range within this List * @throws IndexOutOfBoundsException if an endpoint index value is out of range * {@code (fromIndex < 0 || toIndex > size)} * @throws IllegalArgumentException if the endpoint indices are out of order * {@code (fromIndex > toIndex)} */ /*public synchronized List<E> subList(int fromIndex, int toIndex) { return Collections.synchronizedList(super.subList(fromIndex, toIndex),this); }*/
/** * 移除范围 */ protected synchronized void removeRange(int fromIndex, int toIndex) { modCount++; int numMoved = elementCount - toIndex; System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved); // Let gc do its work int newElementCount = elementCount - (toIndex-fromIndex); while (elementCount != newElementCount) elementData[--elementCount] = null; }
/** * Save the state of the {@code Vector} instance to a stream (that * is, serialize it). * This method performs synchronization to ensure the consistency * of the serialized data. */ /** * @Description: writeObject * @param s * @throws java.io.IOException * @Autor: Jason */ private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException { final java.io.ObjectOutputStream.PutField fields = s.putFields(); final Object[] data; synchronized (this) { fields.put("capacityIncrement", capacityIncrement); fields.put("elementCount", elementCount); data = elementData.clone(); } fields.put("elementData", data); s.writeFields(); }
/** * List 迭代器 */ public synchronized ListIterator<E> listIterator(int index) { if (index < 0 || index > elementCount) throw new IndexOutOfBoundsException("Index: "+index); return new ListItr(index); }
/** * Returns a list iterator over the elements in this list (in proper sequence). */ public synchronized ListIterator<E> listIterator() { return new ListItr(0); }
/** * Returns an iterator over the elements in this list in proper sequence. */ public synchronized Iterator<E> iterator() { return new Itr(); }
/** * @Package：cn.ucaner.sourceanalysis * @ClassName：Itr * @Description： <p> An optimized version of AbstractList.Itr 实现迭代器</p> * @Author： - Jason * @Modify By： * @Modify marker： * @version V1.0 */ private class Itr implements Iterator<E> { int cursor; // index of next element to return int lastRet = -1; // index of last element returned; -1 if no such int expectedModCount = modCount;
public boolean hasNext() { // Racy but within spec, since modifications are checked // within or after synchronization in next/previous return cursor != elementCount; }
public E next() { synchronized (Vector.this) { checkForComodification(); int i = cursor; if (i >= elementCount) throw new NoSuchElementException(); cursor = i + 1; return elementData(lastRet = i); } }
public void remove() { if (lastRet == -1) throw new IllegalStateException(); synchronized (Vector.this) { checkForComodification(); Vector.this.remove(lastRet); expectedModCount = modCount; } cursor = lastRet; lastRet = -1; }
@Override public void forEachRemaining(Consumer<? super E> action) { Objects.requireNonNull(action); synchronized (Vector.this) { final int size = elementCount; int i = cursor; if (i >= size) { return; } @SuppressWarnings("unchecked") final E[] elementData = (E[]) Vector.this.elementData; if (i >= elementData.length) { throw new ConcurrentModificationException(); } while (i != size && modCount == expectedModCount) { action.accept(elementData[i++]); } // update once at end of iteration to reduce heap write traffic cursor = i; lastRet = i - 1; checkForComodification(); } }
final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } }
/** * @Package：cn.ucaner.sourceanalysis * @ClassName：ListItr * @Description： <p> An optimized version of AbstractList.ListItr </p> * @Author： - Jason * @Modify By： * @Modify marker： * @version V1.0 */ final class ListItr extends Itr implements ListIterator<E> { ListItr(int index) { super(); cursor = index; }
public boolean hasPrevious() { return cursor != 0; }
public int nextIndex() { return cursor; }
public int previousIndex() { return cursor - 1; }
public E previous() { synchronized (Vector.this) { checkForComodification(); int i = cursor - 1; if (i < 0) throw new NoSuchElementException(); cursor = i; return elementData(lastRet = i); } }
public void set(E e) { if (lastRet == -1) throw new IllegalStateException(); synchronized (Vector.this) { checkForComodification(); Vector.this.set(lastRet, e); } }
public void add(E e) { int i = cursor; synchronized (Vector.this) { checkForComodification(); Vector.this.add(i, e); expectedModCount = modCount; } cursor = i + 1; lastRet = -1; } }
/** * forEach 增强for循环 */ @Override public synchronized void forEach(Consumer<? super E> action) { Objects.requireNonNull(action); final int expectedModCount = modCount; @SuppressWarnings("unchecked") final E[] elementData = (E[]) this.elementData; final int elementCount = this.elementCount; for (int i=0; modCount == expectedModCount && i < elementCount; i++) { action.accept(elementData[i]); } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } }
/** * removeIf */ @Override @SuppressWarnings("unchecked") public synchronized 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 int size = elementCount; final BitSet removeSet = new BitSet(size); final int expectedModCount = modCount; for (int i=0; modCount == expectedModCount && i < size; i++) { 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 } elementCount = newSize; if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; }
return anyToRemove; }
/** * 替换 */ @Override @SuppressWarnings("unchecked") public synchronized void replaceAll(UnaryOperator<E> operator) { Objects.requireNonNull(operator); final int expectedModCount = modCount; final int size = elementCount; for (int i=0; modCount == expectedModCount && i < size; i++) { elementData[i] = operator.apply((E) elementData[i]); } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; }
/** * 排序 */ @SuppressWarnings("unchecked") @Override public synchronized void sort(Comparator<? super E> c) { final int expectedModCount = modCount; Arrays.sort((E[]) elementData, 0, elementCount, c); if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; }
/** * 分隔符 */ @Override public Spliterator<E> spliterator() { return new VectorSpliterator<>(this, null, 0, -1, 0); }
/** * @Package：cn.ucaner.sourceanalysis * @ClassName：VectorSpliterator * @Description： <p> Similar to ArrayList Spliterator </p> * @Author： - Jason * @Modify By： * @Modify marker： * @version V1.0 */ static final class VectorSpliterator<E> implements Spliterator<E> { private final Vector<E> list; private Object[] array; private int index; // current index, modified on advance/split private int fence; // -1 until used; then one past last index private int expectedModCount; // initialized when fence set
/** * VectorSpliterator. Create new spliterator covering the given range * @param list * @param array * @param origin * @param fence * @param expectedModCount */ VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence, int expectedModCount) { this.list = list; this.array = array; this.index = origin; this.fence = fence; this.expectedModCount = expectedModCount; }
private int getFence() { // initialize on first use int hi; if ((hi = fence) < 0) { synchronized(list) { array = list.elementData; expectedModCount = list.modCount; hi = fence = list.elementCount; } } return hi; }
public Spliterator<E> trySplit() { int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; return (lo >= mid) ? null : new VectorSpliterator<E>(list, array, lo, index = mid, expectedModCount); }
@SuppressWarnings("unchecked") public boolean tryAdvance(Consumer<? super E> action) { int i; if (action == null) throw new NullPointerException(); if (getFence() > (i = index)) { index = i + 1; action.accept((E)array[i]); if (list.modCount != expectedModCount) throw new ConcurrentModificationException(); return true; } return false; }
@SuppressWarnings("unchecked") public void forEachRemaining(Consumer<? super E> action) { int i, hi; // hoist accesses and checks from loop Vector<E> lst; Object[] a; if (action == null) throw new NullPointerException(); if ((lst = list) != null) { if ((hi = fence) < 0) { synchronized(lst) { expectedModCount = lst.modCount; a = array = lst.elementData; hi = fence = lst.elementCount; } } else a = array; if (a != null && (i = index) >= 0 && (index = hi) <= a.length) { while (i < hi) action.accept((E) a[i++]); if (lst.modCount == expectedModCount) return; } } throw new ConcurrentModificationException(); }
public long estimateSize() { return (long) (getFence() - index); }
public int characteristics() { return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED; } }}
Java数据结构Vetor的更多相关文章
- Java数据结构之队列的实现以及队列的应用之----简单生产者消费者应用
Java数据结构之---Queue队列 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在 ...
- JAVA数据结构系列 栈
java数据结构系列之栈 手写栈 1.利用链表做出栈,因为栈的特殊,插入删除操作都是在栈顶进行,链表不用担心栈的长度,所以链表再合适不过了,非常好用,不过它在插入和删除元素的时候,速度比数组栈慢,因为 ...
- Java数据结构之树和二叉树（2）
从这里始将要继续进行Java数据结构的相关讲解,Are you ready?Let's go~~ Java中的数据结构模型可以分为一下几部分: 1.线性结构 2.树形结构 3.图形或者网状结构 接下来 ...
- Java数据结构之树和二叉树
从这里开始将要进行Java数据结构的相关讲解,Are you ready?Let's go~~ Java中的数据结构模型可以分为一下几部分: 1.线性结构 2.树形结构 3.图形或者网状结构 接下来的 ...
- Java数据结构之线性表（2）
从这里开始将要进行Java数据结构的相关讲解,Are you ready?Let's go~~ java中的数据结构模型可以分为一下几部分: 1.线性结构 2.树形结构 3.图形或者网状结构 接下来的 ...
- Java数据结构之线性表
从这里开始将要进行Java数据结构的相关讲解,Are you ready?Let's go~~ java中的数据结构模型可以分为一下几部分: 1.线性结构 2.树形结构 3.图形或者网状结构 接下来的 ...
- java 数据结构 图
以下内容主要来自大话数据结构之中,部分内容参考互联网中其他前辈的博客,主要是在自己理解的基础上进行记录. 图的定义 图是由顶点的有穷非空集合和顶点之间边的集合组成,通过表示为G(V,E),其中,G标示 ...
- java 数据结构 队列的实现
java 数据结构队列的代码实现,可以简单的进行入队列和出队列的操作 /** * java数据结构之队列的实现 * 2016/4/27 **/ package cn.Link; import java ...
- java 数据结构 栈的实现
java数据结构之栈的实现,可是入栈,出栈操作: /** * java数据结构之栈的实现 * 2016/4/26 **/ package cn.Link; public class Stack{ No ...
随机推荐
- LTDC/DMA2D——液晶显示
1.显示器的基本参数 (1) 像素像素是组成图像的最基本单元要素,显示器的像素指它成像最小的点. (2) 分辨率一些嵌入式设备的显示器常常以“行像素值 x列像素值”表示屏幕的分辨率.如分辨率 800x ...
- 图片上传利用request.getInputStream()获取文件流时遇到的问题
图片上传功能是我们web里面经常用到的,获得的方式也有很多种,这里我用的是request.getInputStream()获取文件流的方式.想要获取文件流有两种方式,附上代码 int length = ...
- p2p通信原理及实现
1.简介 当今互联网到处存在着一些中间件(MIddleBoxes),如NAT和防火墙,导致两个(不在同一内网)中的客户端无法直接通信.这些问题即便是到了IPV6时代也会存在,因为即使不需要NAT,但还 ...
- keras Dense 层
文档地址:https://keras.io/layers/core/#dense keras.layers.Dense(units, activation=None, use_bias=True, k ...
- udf提权小结
00x1 首先判断mysql版本, mysql版本 < 5.2 , UDF导出到系统目录c:/windows/system32/ mysql版本 > 5.2 ,UDF导出到安装路径MySQ ...
- Bitmap之compress图片压缩
package com.loaderman.customviewdemo; import android.app.Activity; import android.graphics.Bitmap; i ...
- socket服务端开发之测试使用threading和gevent框架
socket服务端开发之测试使用threading和gevent框架 话题是测试下多线程和gevent在socket服务端的小包表现能力,测试的方法不太严谨,也没有用event loop + pool ...
- shuffle 打乱一维数组
<?php $arr = range(,); print_r($arr); echo '<br />'; shuffle($arr); print_r($arr); ?> Ar ...
- sql 索引【转】
T-SQL查询进阶--理解SQL Server中索引的概念,原理以及其他 简介 在SQL Server中,索引是一种增强式的存在,这意味着,即使没有索引,SQL Server仍然可以实现应有的功能 ...
- halcon学习_字符识别1
实例图片 大体步骤:1.读取图片 2.图像预处理(阈值分割,提取标签部分,缩小处理区域) 3.将标签区域的最小外接矩形,从原图中剪 ...