Comparación de Java Vector y ArrayList
Hoy estudié los códigos fuente de Vector y ArrayList, y profundicé mi comprensión de estas dos clases.
Hay tres clases implementadas en la interfaz de la lista: ArrayList, Vector y LinkedList. No diré mucho sobre LinkedList, generalmente se usa para mantener el orden de inserción de datos.
ArrayList y Vector se implementan utilizando matrices, y hay tres diferencias principales:
1. El vector es multiproceso y seguro, mientras que ArrayList no lo es. Esto se puede ver desde el código fuente. Muchos métodos en la clase vectorial se modifican por sincronizado, lo que conduce a la eficiencia del vector que no se puede comparar con ArrayList;
2. Ambos usan elementos de almacenamiento de espacio continuo lineal, pero cuando el espacio es insuficiente, las dos clases se agregan de manera diferente. Muchos internautas dicen que Vector duplica el espacio original, y ArrayList aumenta el espacio original en un 50%. De hecho, esto es lo mismo. Sin embargo, todavía hay algunos problemas que se pueden ver desde el código fuente, y se analizará desde el código fuente más adelante.
3. El vector puede establecer el factor de crecimiento, pero ArrayList no puede. Cuando miré esto por primera vez, no entendí cuál era el factor incremental. Sin embargo, entendí esto comparando los dos códigos de origen. Primero veamos los métodos de construcción de las dos clases:
ArrayList tiene tres métodos de construcción:
Public ArrayList (int InitialCapacity) // Construye una lista vacía con la capacidad inicial especificada. Public ArrayList () // Construye una lista vacía con una capacidad inicial de 10. Public ArrayList (Collection <? Extends e> c) // Construye una lista de elementos que contienen la colección especificada
Vector tiene cuatro constructores:
Public Vector () // Construye un vector vacío utilizando la capacidad inicial especificada y el incremento de capacidad igual a cero. Public Vector (int InitialCapacity) // Construye un vector vacío para hacer el tamaño de su matriz de datos internos, y su incremento de capacidad estándar es cero. Public Vector (Collection <? Extends e> c) // Construye un vector que contenga elementos en la colección especificada Vector público (int InitialCapacity, Int CapacityIncrement) // Construye un vector vacío utilizando los incrementos de capacidad iniciales especificados
Vector tiene un método de construcción más que ArrayList. Así es, el método de construcción del vector público (int InitialCapacity, Int CapacityIncrement). CapacityIncrement es el crecimiento de la capacidad, que es el factor de crecimiento mencionado anteriormente, que no está disponible en ArrayList.
Luego publique dos clases para agregar análisis del código fuente (versión JDK1.7):
// CLASE DE ARRAYLIST ADD Código fuente: public boolean add (E e) {EnsurecapacityInternal (tamaño + 1); // incrementa modcount! elementData [size ++] = e; devolver verdadero; } private vacío ensaladointernal (int mincapacity) {modCount ++; // Código consciente de desbordamiento // Si después de agregar un elemento, el tamaño del nuevo contenedor es mayor que la capacidad del contenedor, entonces el valor no se puede guardar. El espacio debe ampliarse si (mincapacity - elementData.length> 0) crece (mincapacity); } private void grow (int mincapacity) {// código de desbordamiento-consciente int OldCapacity = elementData.length; int newCapacity = OldCapacity + (OldCapacity >> 1); // El espacio de expansión aumenta en un 50% (es decir, 1,5 veces el original) if (newcapacity - mincapacity <0) // Si el contenedor aún no es suficiente después de la expansión, simplemente establezca la mincapacidad en el tamaño del contenedor newcapacity = mincapacity; if (newCapacity - max_array_size> 0) // Si el contenedor expandido es demasiado grande, entonces ejecute hugecapacity newCapacity = HugeCapacity (mincapacity); // La mincapacidad generalmente está cerca del tamaño, por lo que esta es una victoria: elementData = arrays.copyOf (elementData, newCapacity); } Agregue el código fuente a la clase Vector:
public sincronizado boolean add (e e) {modcount ++; EnsurecapacityHelper (ElementCount + 1); elementData [elementCount ++] = e; devolver verdadero; } private void setureCapacityHelper (int mincapacity) {// Código consciente de desbordamiento if (mincapacity - elementData.length> 0) Grow (minCapacity); } private void grow (int mincapacity) {// código de desbordamiento-consciente int OldCapacity = elementData.length; int NewCapacity = OldCapacity + ((CapacityIncrement> 0)? CapacityIncrement: OldCapacity); /** Esta expansión de la capacidad requiere un juicio: si el incremento de capacidad no se inicializa con 0, es decir, la inicialización del constructor de vectores públicos (int inicial de capacidad inicial, int capacidad), entonces la capacidad de expansión de la capacidad es (con capacidad de antaño+capacidad de capacidad), que es el valor de la capacidad original más el incremento de capacidad; Si no se establece el incremento de capacidad, entonces la capacidad después de la expansión es (Old -Capacity+OldCapacity), que es el doble de la capacidad original. **/ if (newCapacity - mincapacity <0) newCapacity = mincapacity; if (newCapacity - max_array_size> 0) newCapacity = HugeCapacity (mincapacity); elementData = arrays.copyOf (elementData, newCapacity); }A través del análisis, ¡debería ser comprensible ahora!
Gracias por leer, espero que pueda ayudarte. ¡Gracias por su apoyo para este sitio!