集合—Vector源码

Vector（2021-11-3）

1 Collection接口遍历元素方式：

• 使用迭代器。
• for循环增强。

1-1 迭代器遍历

• 迭代器基本介绍：
  • Interator对象成为迭代器，主要用于遍历Collection集合中的元素。
  • 所有实现了Collection接口的集合类都有一个interator（）方法，用于返回一个实现了Interator接口的对象，即可以返回一个迭代器。
  • Interator仅用于遍历集合，Interator本身不存放对象。
• Interator结构：

Iterator iterator = coll.iterator() //得到一个集合的迭代器
//hasNext():判断是否有下一个元素
while(iterator.hasNext()){ //判断是否还有数据。
	//next()作用:
	//(1)指针下移；
    //(2)将下移以后集合位置上的元素返回。
    Object object = iterator.next();
    System.out.println(object);
}
//while(iterator.hasNext()){} 快捷键：itit + enter
//显示所有快捷键的快捷键：ctrl + j

//当迭代器推出while循环后，这是iterator迭代器，指向最后一个元素。
//如果希望再次遍历，需要重置iterator迭代器：
iterator = col.iterator();

• 在使用iterator.next()方法前必须要调用iterator.hasNext()进行检测。若不调用，下一条记录无效，直接调用iterator.next()会抛出NoSuchElementException异常。

1-2 for循环增强

• 增强for循环，可以替代迭代器。可以理解为简化版的迭代器Interator。本质一样，只能用于遍历集合和数组。
• 基本语法：

//使用增强for,在Collection集合。
//底层仍然是迭代器。
Collection col = new ArrayList();
for(Object object:col){ //增强for
    System.out.println(object);
}

//增强for也可以直接在数组使用。
int[] nums = {1,2,3,4};
for(int i : nums){
    System.out.println(i);
}

2 List接口和常用方法

• List集合类中的元素是有序的（添加和取出的顺序一致），可以重复。

• add(int index , Object ele)。

• get(int index) 获取指定index位置的元素 。

• indexOf(Object obj) 返回obj在集合中首次出现的位置 。

• LastIndexOf(Object obj) 返回obj自己和中末次出现的位置 。

• remove(int index) 移除指定的 index 元素 。

• set(int index , Object obj) 替换 。

• subList(int fromIndex , int toIndex) 返回 [ fromIndex，toIndex ] 的元素 。

3 ArrayList注意事项

• ArrayList基本等同于Vector，除了ArrayList是线程不安全的（执行效率高）：没有sysnchronizd。

• 在多线程情况下，不建议使用ArrayList。

4 Vector

• 底层：对象数组。

protected Object[] elementData;

• Vector是线程同步的（线程安全）。

public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
}

• 开发中，需要线程同步安全时，考虑使用Vector。

5 Vector底层结构和ArrayList比较

List	底层结构	版本	线程安全（同步）效率	扩容倍数
ArrayList	可变数组	jdk1.2	不安全，效率高	1）有参构造：1.5 2）无参构造： 第一次10 第二次开始1.5
Vector	可变数组	jdk1.0	安全，效率低	1）无参构造：默认10，满后，按照2倍扩容 2）有参构造：2

5-1 Vector源码

• 无参构造：

public Vector() {
    this(（initialCapacity = ）10);   //直接默认是10
    public Vector(int initialCapacity （10）) {
        this(initialCapacity（10）, 0);
        public Vector(int initialCapacity, int capacityIncrement) {
            super();
            if (initialCapacity（10） < 0)  //判断长度值是否异常
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            this.elementData = new Object[initialCapacity（10）];
            this.capacityIncrement = capacityIncrement;
    	}
    }
}
10 -> 20 -> 40 -> 80`````

• add(无参构造第一次)：

public synchronized boolean add(E e) { //添加数据到Vector集合
    modCount++;
    
    ensureCapacityHelper(elementCount + 1){
        if (minCapacity - elementData.length > 0) //确定是否需要扩容
            grow(minCapacity){//真正扩容 例子：第一次扩容
            	// 10
            	int oldCapacity = elementData.length;
            	// new = old + (a)?(b = old) [a真返回a ； a假返回b]
            	// capacityIncrement固定是0 - 为什么还要有呢？直接*2不好吗？
                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);
			}; 
        
	};
    
    elementData[elementCount++] = e;
    return true;
}

• 有参构造：

public Vector(int initialCapacity（0）) {
	this(initialCapacity（0）, （capacityIncrement = ）0); //capacityIncrement固定是0 。
    public Vector(int initialCapacity（0）, int capacityIncrement（0）) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];（0）
        this.capacityIncrement = capacityIncrement; // 0=0
    }
}
n>0
n -> 2n -> 4n -> 8n``````

• add(有参传0第一次)：

public synchronized boolean add(E e) { //添加数据到Vector集合
    modCount++;
    
    ensureCapacityHelper(（minCapacity = ）elementCount（0） + 1){
        if (minCapacity（1） - elementData.length（0） > 0) //确定是否需要扩容
            grow(minCapacity){//真正扩容 例子：第一次扩容
            	// 10
            	int oldCapacity（0） = elementData.length;
            	// new = old + (a)?(b = old) [a真返回a ； a假返回b]
            	// capacityIncrement固定是0 - 为什么还要有呢？直接*2不好吗？
            	//capacityIncrement : 容量 盈余
                int newCapacity（0） = oldCapacity（0） + ((capacityIncrement（0） > 0) ?
                                                 capacityIncrement : oldCapacity（0）);
                if (newCapacity（0） - minCapacity（1） < 0)
                    newCapacity（1） = minCapacity（1）;//只有传参0，第一次扩容进来！
                if (newCapacity - MAX_ARRAY_SIZE > 0)  //不用看
                    newCapacity = hugeCapacity(minCapacity);
                elementData = Arrays.copyOf(elementData, newCapacity);
			}; 
        
	};
    
    elementData[elementCount++] = e;
    return true;
}
1 -> 2 -> 4 -> 8 -> 16``````