resultados de los datos - Vector, Stack

Vector

breve introducción

array thread-safe dinámico, muy similar a ArrayList. JDK1.0 añadir la clase Vector. Vector puede mantener el mismo orden de inserción, pero vector contiene muchos métodos tradicionales, que no pertenecen al marco conjunto

categoría

public class Vector<E>
        extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

propiedad

// 元素数组
protected Object[] elementData;
// 元素个数
protected int elementCount;
// 增量长度
protected int capacityIncrement;
// 修改次数, 每次add、remove它的值都会加1（这个属性是AbstractList中的）
protected transient int modCount = 0;
// 默认最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

constructor

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    // 初始长度小于0时抛异常
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    // 创建元素数组
    this.elementData = new Object[initialCapacity];
    // 指定增长长度
    this.capacityIncrement = capacityIncrement;
}
public Vector(int initialCapacity) {
    // 一个参数构造函数默认指定，增长长度为0
    this(initialCapacity, 0);
}
public Vector() {
    // 空参构造函数，制定初始数组长度10
    this(10);
}
public Vector(Collection<? extends E> c) {
    // 参数集合转数组，赋值给元素数组
    elementData = c.toArray();
    // 设置元素个数
    elementCount = elementData.length;
    // 不是Object数组时转为Object数组
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}

Como puede verse desde el constructor para crear los elementos de la matriz 10 inicializa una longitud, una longitud de crecimiento de sólo la primera constructor con un valor de ajuste, el otro es 0

enfoque basado

public synchronized int size() {
    // 返回元素个数
    return elementCount;
}
public synchronized boolean isEmpty() {
    // 元素个数为0时返回true
    return elementCount == 0;
}

Establecer la longitud

public synchronized void setSize(int newSize) {
    // 修改次数加1
    modCount++;
    // 判断是否需要扩容
    if (newSize > elementCount) {
        ensureCapacityHelper(newSize);
    } else {
        // 参数以后的元素清空掉
        for (int i = newSize ; i < elementCount ; i++) {
            elementData[i] = null;
        }
    }
    elementCount = newSize;
}
private void ensureCapacityHelper(int minCapacity) {
    // 判断新长度是否大于原数组长度，大于则扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

Al utilizar la nueva longitud de la expansión es menor que la longitud de la nueva serie de elementos de la matriz de la etapa original, el nuevo elemento es mayor que la longitud de la longitud de la matriz

expansión

private void grow(int minCapacity) {
    // 获取原长度
    int oldCapacity = elementData.length;
    // 获取新长度
    // 增长长度不为0时 新长度=原长度+增长长度
    // 增长长度不为0时 新长度=原长度+增长长度
    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);
}
private static int hugeCapacity(int minCapacity) {
    // 长度小于0则抛异常
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    // 长度大于默认最大值取Integer最大值
    return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}

Vector de expansión especial, a diferencia de ArrayList, ArrayList no longitudinal crecimiento expansión en circunstancias normales es de sólo 1,5 veces la longitud original, y cuando la expansión Vector, primero determina si la longitud es cero crecimiento, aumentar la longitud de uso no es 0, 0 cuando la longitud original multiplicada por 2

Elementos hallazgo

Mirando desde delante hacia atrás

public int indexOf(Object o) {
    return indexOf(o, 0);
}
public synchronized int indexOf(Object o, int index) {
    if (o == null) {
        // index为起始位置
        for (int i = index ; i < elementCount ; i++)
            // 查找元素为空
            if (elementData[i]==null)
                return i;
    } else {
        // index为起始位置
        for (int i = index ; i < elementCount ; i++)
            // 查找equals一样的元素
            if (o.equals(elementData[i]))
                return i;
    }
    // 没有找到返回-1
    return -1;
}

Desde la parte de atrás para encontrar

public synchronized int lastIndexOf(Object o) {
    return lastIndexOf(o, elementCount-1);
}
public synchronized int lastIndexOf(Object o, int index) {
    // 判断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;
    }
    // 没有找到返回-1
    return -1;
}

las operaciones de elemento de matriz

public Enumeration<E> elements() {
    // 每次调用此方法都会有一个新对象
    return new Enumeration<E>() {
        int count = 0;

        public boolean hasMoreElements() {
            return count < elementCount;
        }

        public E nextElement() {
            // 虽然方法上没加锁，但是这儿加了，锁的是当前对象
            synchronized (java.util.Vector.this) {
                if (count < elementCount) {
                    return elementData(count++);
                }
            }
            throw new NoSuchElementException("Vector Enumeration");
        }
    };
}

Aquí la transmisión de enumeración, interfaz Enumeration define los métodos, estos métodos se pueden enumerar (una vez para obtener a) objeto elemento de la colección. Esta interfaz tradicional ha sido sustituida por un iterador, aunque la enumeración no se ha abandonado, pero en moderno código ha sido rara vez se utiliza.
El primer elemento antes y después

public synchronized E firstElement() {
    // 数组为空时抛异常
    if (elementCount == 0) {
        throw new NoSuchElementException();
    }
    return elementData(0);
}
public synchronized E lastElement() {
    // 数组为空时抛异常
    if (elementCount == 0) {
        throw new NoSuchElementException();
    }
    // 取最后一个元素
    return elementData(elementCount - 1);
}

Índice de elementos hallazgo

E elementData(int index) {
    // 通过索引直接从数组中取值
    return (E) elementData[index];
}
public synchronized E elementAt(int index) {
    // 判断索引是否大于元素个数
    if (index >= elementCount) {
        throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
    }
    return elementData(index);
}
public synchronized void setElementAt(E obj, int index) {
    // 超过元素个数抛异常
    if (index >= elementCount) {
        throw new ArrayIndexOutOfBoundsException(index + " >= " +
                elementCount);
    }
    // 根据索引设值
    elementData[index] = obj;
}

Eliminar los elementos especificados en la localización

public synchronized void removeElementAt(int index) {
    modCount++;
    // 判断指定索引是否超过元素个数
    if (index >= elementCount) {
        throw new ArrayIndexOutOfBoundsException(index + " >= " +
                elementCount);
    }
    // 索引不能小于0
    else if (index < 0) {
        throw new ArrayIndexOutOfBoundsException(index);
    }
    // 索引位置以后的元素前向前移动
    int j = elementCount - index - 1;
    if (j > 0) {
        System.arraycopy(elementData, index + 1, elementData, index, j);
    }
    // 元素个数减1
    elementCount--;
    // 最后一个元素置空
    elementData[elementCount] = null; /* to let gc do its work */
}

Insertar el elemento en la posición especificada

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++;
}

elementos adicionales

public synchronized void addElement(E obj) {
    modCount++;
    // 判断是否需要扩容
    ensureCapacityHelper(elementCount + 1);
    // 末尾增加元素
    elementData[elementCount++] = obj;
}

La eliminación de los elementos

public synchronized boolean removeElement(Object obj) {
    modCount++;
    // 找到元素位置
    int i = indexOf(obj);
    // 存在就删除
    if (i >= 0) {
        removeElementAt(i);
        return true;
    }
    return false;
}

Eliminar todos los elementos

public synchronized void removeAllElements() {
    modCount++;
    // 遍历索引元素，依次置空
    for (int i = 0; i < elementCount; i++)
        elementData[i] = null;

    elementCount = 0;
}

Agregar Quitar

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

Añadir método Remove es utilizar también el método anterior, no aquí en la repetición

Siga el método de la clase padre

public synchronized boolean containsAll(Collection<?> c) {
    return super.containsAll(c);
}
public synchronized boolean removeAll(Collection<?> c) {
    return super.removeAll(c);
}
public synchronized boolean retainAll(Collection<?> c) {
    return super.retainAll(c);
}
public synchronized boolean equals(Object o) {
    return super.equals(o);
}
public synchronized int hashCode() {
    return super.hashCode();
}
public synchronized String toString() {
    return super.toString();
}

El método de la clase padre de la lista de artículos de referencia de interfaz

Las clases internas

private class Itr implements Iterator<E>
final class ListItr extends java.util.Vector.Itr implements ListIterator<E>
static final class VectorSpliterator<E> implements Spliterator<E>

Apilar

breve introducción

Una pila o supresión sólo se pueden insertar en un extremo de la mesa lineal, último en salir tabla

categoría

public class Stack<E> extends Vector<E>

Nota heredado del vector

public E push(E item) {
    addElement(item);

    return item;
}
public synchronized E pop() {
    E obj;
    int len = size();
    obj = peek();
    removeElementAt(len - 1);
    return obj;
}
public synchronized E peek() {
    int len = size();
    // 判断长度
    if (len == 0)
        throw new EmptyStackException();
    // 调用Vector中的方法
    return elementAt(len - 1);
}

Método propio raramente, principalmente en el pop pila