Java集合之Vector
Vector是矢量队列,它继承了AbstractList,实现了List、 RandomAccess, Cloneable, java.io.Serializable接口。
Integer value=null;
Iterator iter=vector.iterator();
while(iter.hasNext())
{
value=(Interger)iter.next();
}
Integer value=null;
int size=vector.size();
for(int i=0;i<size;i++)
{
value=vector.get(i);
}
Integer value=null;
for( Integer inte: vector)
{
value=inte;
}
Integer value=null;
Enumeration enu=vector.elements();
while(enu.hasMoreElements())
{
value=(Integer)enu.nextElement();
}
public class Hello {
public static void main(String[] args) {
Vector vec = new Vector();
//添加
vec.add("1");
vec.add("2");
vec.add("3");
vec.add("4");
vec.add("5");
//替换
vec.set(0, "100");
vec.add(2, "300");
System.out.println("vec:"+vec);
System.out.println("vec.indexOf(100):"+vec.indexOf("100"));
System.out.println("vec.lastIndexOf(100):"+vec.lastIndexOf("100"));
System.out.println("vec.firstElement():"+vec.firstElement());
System.out.println("vec.elementAt(2):"+vec.elementAt(2));
System.out.println("vec.lastElement():"+vec.lastElement());
System.out.println("size:"+vec.size());
System.out.println("capacity:"+vec.capacity());
System.out.println("vec 2 to 4:"+vec.subList(1, 4));
Enumeration enu = vec.elements();
while(enu.hasMoreElements())
{
System.out.println("nextElement():"+enu.nextElement());
Vector retainVec = new Vector();
retainVec.add("100");
retainVec.add("300");
System.out.println("vec.retain():"+vec.retainAll(retainVec));
System.out.println("vec:"+vec);
String[] arr = (String[]) vec.toArray(new String[0]);
for (String str:arr)
System.out.println("str:"+str);
vec.clear();
vec.removeAllElements();
System.out.println("vec.isEmpty():"+vec.isEmpty());
}
}
}
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { protected Object[] elementData;//对象数组,来存放数据 protected int elementCount; //当前的数据数目 protected int capacityIncrement; //容量增长 private static final long serialVersionUID = -2767605614048989439L; //序列号 //构造函数矢量队列初始化大小和增长大小 public Vector(int initialCapacity, int capacityIncrement) { super(); ) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; this.capacityIncrement = capacityIncrement; } //构造函数初始化大小 public Vector(int initialCapacity) { ); } //构造函数默认初始化大小10 public Vector() { ); } //带有集合参数的构造函数 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); } //线程安全的对象数组拷贝 public synchronized void copyInto(Object[] anArray) { System.arraycopy(, elementCount); } //调整容量大小适合当前矢量队列的大小 public synchronized void trimToSize() { modCount++; int oldCapacity = elementData.length; if (elementCount < oldCapacity) { elementData = Arrays.copyOf(elementData, elementCount); } } //增加矢量队列的容量大小 public synchronized void ensureCapacity(int minCapacity) { ) { modCount++; ensureCapacityHelper(minCapacity); } } private void ensureCapacityHelper(int minCapacity) { // overflow-conscious code ) grow(minCapacity); } ; private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; ) ? capacityIncrement : oldCapacity); ) newCapacity = minCapacity; ) newCapacity = hugeCapacity(minCapacity); elementData = Arrays.copyOf(elementData, newCapacity); } private static int hugeCapacity(int minCapacity) { ) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; } //调整大小,如果超出了就删掉多余的对象 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; } //矢量对象的容量 public synchronized int capacity() { return elementData.length; } //矢量队列的大小 public synchronized int size() { return elementCount; } //是否为空 public synchronized boolean isEmpty() { ; } //生成Enumeration对象,进行遍历 public Enumeration<E> elements() { return new Enumeration<E>() { ; 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) { ) >= ; } //返回某个对象的下标 public int indexOf(Object o) { ); } 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; } ; } //最后出现的对象的坐标 public synchronized int lastIndexOf(Object o) { ); } public synchronized int lastIndexOf(Object o, int index) { if (index >= elementCount) throw new IndexOutOfBoundsException(index + " >= "+ elementCount); if (o == null) { ; i--) if (elementData[i]==null) return i; } else { ; i--) if (o.equals(elementData[i])) return i; } ; } //返回某个坐标的节点 public synchronized E elementAt(int index) { if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); } return elementData(index); } //第一个元素 public synchronized E firstElement() { ) { throw new NoSuchElementException(); } ); } //最后一个元素 public synchronized E lastElement() { ) { throw new NoSuchElementException(); } ); } //对下标为index的元素替换为obj public synchronized void setElementAt(E obj, int index) { if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); } elementData[index] = obj; } //删除某个下标的元素 public synchronized void removeElementAt(int index) { modCount++; if (index >= elementCount) { throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); } ) { throw new ArrayIndexOutOfBoundsException(index); } ; ) { System.arraycopy(, elementData, index, j); } elementCount--; elementData[elementCount] = null; /* to let gc do its work */ } //在index坐标后添加obj public synchronized void insertElementAt(E obj, int index) { modCount++; if (index > elementCount) { throw new ArrayIndexOutOfBoundsException(index + " > " + elementCount); } ensureCapacityHelper(); , elementCount - index); elementData[index] = obj; elementCount++; } //矢量队列末尾添加元素 public synchronized void addElement(E obj) { modCount++; ); elementData[elementCount++] = obj; } //删除obj元素 public synchronized boolean removeElement(Object obj) { modCount++; int i = indexOf(obj); ) { removeElementAt(i); return true; } return false; } //清空所有元素 public synchronized void removeAllElements() { modCount++; // Let gc do its work ; i < elementCount; i++) elementData[i] = null; ; } //克隆 public synchronized Object clone() { try { @SuppressWarnings("unchecked") Vector<E> v = (Vector<E>) super.clone(); v.elementData = Arrays.copyOf(elementData, elementCount); ; return v; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(e); } } //生成数组 public synchronized Object[] toArray() { return Arrays.copyOf(elementData, elementCount); } @SuppressWarnings("unchecked") public synchronized <T> T[] toArray(T[] a) { if (a.length < elementCount) return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass()); , elementCount); if (a.length > elementCount) a[elementCount] = null; return a; } @SuppressWarnings("unchecked") E elementData(int index) { return (E) elementData[index]; } //得到index的元素 public synchronized E get(int index) { if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); return elementData(index); } //将index元素替换成element 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++; ); elementData[elementCount++] = e; return true; } //删除对象 public boolean remove(Object o) { return removeElement(o); } //在index处添加元素 public void add(int index, E element) { insertElementAt(element, index); } //删除index处元素 public synchronized E remove(int index) { modCount++; if (index >= elementCount) throw new ArrayIndexOutOfBoundsException(index); E oldValue = elementData(index); ; ) System.arraycopy(, elementData, index, numMoved); elementData[--elementCount] = null; // Let gc do its work return oldValue; } //清空元素 public void clear() { removeAllElements(); } //判断Vector中是否含有所有的Collection public synchronized boolean containsAll(Collection<?> c) { return super.containsAll(c); } //将Collection添加到矢量队列的队尾 public synchronized boolean addAll(Collection<? extends E> c) { modCount++; Object[] a = c.toArray(); int numNew = a.length; ensureCapacityHelper(elementCount + numNew); , elementData, elementCount, numNew); elementCount += numNew; ; } //删除包含Collection的元素 public synchronized boolean removeAll(Collection<?> c) { return super.removeAll(c); } //删除不存在Collection的元素 public synchronized boolean retainAll(Collection<?> c) { return super.retainAll(c); } //在某个index之后追加集合 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; ) System.arraycopy(elementData, index, elementData, index + numNew, numMoved); , elementData, index, numNew); elementCount += numNew; ; } //判断矢量队列是否相同 public synchronized boolean equals(Object o) { return super.equals(o); } //返回hashCode public synchronized int hashCode() { return super.hashCode(); } // public synchronized String toString() { return super.toString(); } //切断 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; } //序列化 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(); } //迭代 public synchronized ListIterator<E> listIterator(int index) { if (index < 0 || index > elementCount) throw new IndexOutOfBoundsException("Index: "+index); return new ListItr(index); } public synchronized ListIterator<E> listIterator() { ); } public synchronized Iterator<E> iterator() { return new Itr(); } private class Itr implements Iterator<E> { int cursor; // index of next element to return ; // 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(); ; return elementData(lastRet = i); } } public void remove() { ) throw new IllegalStateException(); synchronized (Vector.this) { checkForComodification(); Vector.this.remove(lastRet); expectedModCount = modCount; } cursor = lastRet; ; } @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; ; checkForComodification(); } } final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } } final class ListItr extends Itr implements ListIterator<E> { ListItr(int index) { super(); cursor = index; } public boolean hasPrevious() { ; } public int nextIndex() { return cursor; } public int previousIndex() { ; } public E previous() { synchronized (Vector.this) { checkForComodification(); ; ) throw new NoSuchElementException(); cursor = i; return elementData(lastRet = i); } } public void set(E e) { ) 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; } ; ; } } @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; ; modCount == expectedModCount && i < elementCount; i++) { action.accept(elementData[i]); } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } } @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 ; final int size = elementCount; final BitSet removeSet = new BitSet(size); final int expectedModCount = modCount; ; modCount == expectedModCount && i < size; i++) { @SuppressWarnings("unchecked") 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 ; if (anyToRemove) { final int newSize = size - removeCount; ; (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; ; 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; , elementCount, c); if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; } @Override public Spliterator<E> spliterator() { ); } /** Similar to ArrayList Spliterator */ 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 /** Create new spliterator covering the given range */ 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; ) { synchronized(list) { array = list.elementData; expectedModCount = list.modCount; hi = fence = list.elementCount; } } return hi; } public Spliterator<E> trySplit() { ; 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)) { ; 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) { ) { 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集合之Vector的更多相关文章
- Java基础系列 - JAVA集合ArrayList,Vector,HashMap,HashTable等使用
package com.test4; import java.util.*; /** * JAVA集合ArrayList,Vector,HashMap,HashTable等使用 */ public c ...
- java集合之vector容器
学完ArrayList和LinkedList之后,我们接着学习Vector.第1部分 Vector介绍第2部分 Vector数据结构第3部分 Vector源码解析(基于JDK1.6.0_45)第4部分 ...
- java集合之Vector向量基础
Vector向量: vector类似动态数组,向量和数组类似,但是数组容量一旦确定不可更改,而向量的容量可变.向量只可以保存任何类型对象且容量不限制,数组对元素类型无限制但是容量有限. 适用场合:向量 ...
- Java集合之Vector源码分析
概述 Vector与ArrayLIst类似, 内部同样维护一个数组, Vector是线程安全的. 方法与ArrayList大体一致, 只是加上 synchronized 关键字, 保证线程安全, 下面 ...
- java 集合(Vector)不做重点
Vector: 底层也是维护了一个Object数组,实现与ArrayList是一样的, 但其线程是安全的,效率低.除了比较老的系统,是不会用到的. 笔试题:ArrayList 和 Vector 的区别 ...
- Java集合源码分析(四)Vector<E>
Vector<E>简介 Vector也是基于数组实现的,是一个动态数组,其容量能自动增长. Vector是JDK1.0引入了,它的很多实现方法都加入了同步语句,因此是线程安全的(其实也只是 ...
- Java 集合系列06之 Vector详细介绍(源码解析)和使用示例
概要 学完ArrayList和LinkedList之后,我们接着学习Vector.学习方式还是和之前一样,先对Vector有个整体认识,然后再学习它的源码:最后再通过实例来学会使用它.第1部分 Vec ...
- Java 集合系列 05 Vector详细介绍(源码解析)和使用示例
java 集合系列目录: Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java ...
- Java 集合深入理解(12):古老的 Vector
点击查看 Java 集合框架深入理解 系列, - ( ゜- ゜)つロ 乾杯~ 今天刮台风,躲屋里看看 Vector ! 都说 Vector 是线程安全的 ArrayList,今天来根据源码看看是不是这 ...
随机推荐
- 【Java集合系列】---ArrayList
开篇前言--ArrayList中的基本方法 前面的博文中,小编主要简单介绍java集合的总体架构,在接下来的博文中,小编将详细介绍里面的各个类,通过demo.对比,来对java集合类进行更加深入的理解 ...
- linux下内存大小、起始地址的解析与修改
在实际的工作中,由于产品型号的不同,经常需要调整linux所管理的内存的大小,而内核在启动阶段,会两次去解析从uboot传递过来的关于内存的信息,具体如下: 一.解析从uboot传递过来的tag(在p ...
- 大数据基础知识问答----spark篇,大数据生态圈
Spark相关知识点 1.Spark基础知识 1.Spark是什么? UCBerkeley AMPlab所开源的类HadoopMapReduce的通用的并行计算框架 dfsSpark基于mapredu ...
- AsyncTask函数化的封装,AsyncTask函数式的调用
AsyncTask在本专栏已经做过详细的解析,但是AsyncTask函数式的调用这个概念对大多数人来说比较陌生.其实本质就是自己封装AsyncTask,让暴露的方法,看不到一点AsyncTask的身影 ...
- nginx中configure脚本支持的常用选项,拍摄自《Nginx高性能Web服务器详解》
- React native和原生之间的通信
RN中文网关于原生模块(Android)的介绍可以看到,RN前端与原生模块之 间通信,主要有三种方法: 1)使用回调函数Callback,它提供了一个函数来把返回值传回给JavaScript. 2)使 ...
- Gazebo機器人仿真學習探索筆記(四)模型編輯
模型編輯主要是自定義編輯物體模型構建環境,也可以將多種模型組合爲新模型等,支持外部模型導入, 需要注意的導入模型格式有相應要求,否在無法導入成功, COLLADA (dae), STereoLitho ...
- IMDG中的陷阱和问题
陷阱 使用cache API时,一个最重要的问题就是潜在的数据加载.因为IMDG提供的分布式集合也都是实现的JDK的Map.Set等接口,以JDK的Map为例,它接口规定put和remove返回被替换 ...
- iOS开发之Xcode常用调试(Debug)技巧总结
一.Xcode调试技巧之:NSLog 上面也提到了,在我们日常的开发过程中最常见的Debug方式就是打Log.而在OC语言中,打Log是采用NSLog方法.但是NSLog效率低下,具体原因可以看这篇博 ...
- shell的数值计算,小数计算
shell脚本中,可以进行数值计算, 如加减乘除,通过expr.let.(())等完成,文章介绍:http://blog.csdn.net/longshenlmj/article/details/14 ...