Descripción general de ArrayList:
ArrayList se implementa en función de las matrices y es una matriz dinámica cuya capacidad puede crecer automáticamente, similar a la memoria de aplicación dinámica en el lenguaje C, que aumenta dinámicamente la memoria.
ArrayList no es segura de subprocesos y solo se puede usar en un entorno único. En un entorno múltiple, puede considerar usar la función de colección. SynchronizedList (List l) para devolver una clase de ArrayList segura a hilo, o puede usar la clase CopyOnWriteArrayList en el paquete concurrente concurrente.
ArrayList implementa la interfaz serializable, por lo que admite la serialización, puede transmitirse a través de la serialización, implementa la interfaz RandomAccess y admite un acceso aleatorio rápido. De hecho, es un acceso rápido a través del número de serie subíndice, implementa la interfaz clonable y puede clonarse.
Cada instancia de ArrayList tiene una capacidad, que se refiere al tamaño de la matriz utilizada para almacenar elementos de la lista. Siempre es al menos igual al tamaño de la lista. A medida que los elementos se agregan constantemente a ArrayList, su capacidad también aumenta automáticamente. El crecimiento automático traerá una recuperación de datos a la nueva matriz, por lo que si puede predecir la cantidad de datos, puede especificar su capacidad al construir una lista de matrices. Antes de agregar una gran cantidad de elementos, la aplicación también puede usar la operación de capacidad Ensurecapacidad para aumentar la capacidad de la instancia de ArrayList, lo que puede reducir el número de redistribuciones incrementales.
Tenga en cuenta que esta implementación no es sincrónica. Si múltiples hilos acceden a una instancia de ArrayList al mismo tiempo, y al menos uno de los hilos modifica estructuralmente la lista, debe permanecer sincronizado externamente.
Hagamos un registro y resumen de Java ArrayList
Public Class ArrayList <E> { / *** Elementos que almacenan la colección** / objeto transitorio privado [] elementData; / ** Tamaño del elemento*/ Tamaño de intivate int;Defina una clase genérica, una matriz de objeto y una variable privada para registrar el número de elementos en la colección. Hay una variable privada adicional en el texto original, y no sé qué usarlo, y el autor no tiene explicación ni lo menciona. Está bien si no lo usé.
/ ** * Inicializar de acuerdo con el tamaño especificado * @param InitialCapacity */ Public ArrayList (int InitialCapacity) {super (); if (inicialCapacity <= 0) {// Excepción Agregue nueva IllegalArgumentException ("El parámetro de inicialización no puede ser inferior a 0"); } else {// Inicializar la matriz this.ElementData = new Object [InitialCapacity]; }} / *** Inicialización predeterminada* / public arrayList () {this (10); } /*** Inicializar de acuerdo con una clase de colección* @param c una clase que debe heredar la interfaz de colección* /public arrayList (colección <? Extends e> c) {// inicialize elementData = c.toarray (); size = elementData.length; // Convertir el tipo de objeto if (elementData.getClass ()! = Object []. Class) {elementData = arrays.copyOf (elementData, size, object []. Class); }} 3 Métodos de inicialización, inicialice la matriz de acuerdo con el tamaño predeterminado, inicialice el tamaño dado y pase una clase que hereda la interfaz de colección de colección para la inicialización de la asignación de conversión
/ *** Colección de expansión* @param mincapacity*/ public void setureCapacity (int mincapacity) {/ ** tamaño actual de la matriz*/ int if (minCapacity> OldCapacity) { /*** Aunque no se usa OldData, se trata de administración de memoria y el método Arrays.CopyOf () no es seguro* OldData OldData se refiere a la variable ElementData durante el ciclo de vida de IF, por lo que GC* no se puede reciclar con la reciclaje de la reciclaje de la reciclaje. La memoria de elementos de elementos al estar invadido. * Cuando el final sale de si el ciclo de los viejos días termina y se recicla*/ objeto OldData [] = elementData; int newCapacity = (OldCapacity * 3)/2 + 1; // aumentar 50%+1 if (newCapacity <mincapacity) newCapacity = mincapacity; // use matrizs.copyOf para copiar los elementos de la colección y generar una nueva matriz elementData = arrays.copyOf, newCapacity); }}Este es un método central. La expansión del conjunto es en realidad comparar la expansión de la matriz y el tamaño de la colección de mincapacidad para determinar si debe ampliarse. El método Arrays.CopyOf () se utiliza para la expansión.
El texto original tiene una explicación detallada. Este método copia el contenido del primer parámetro a una nueva matriz. El tamaño de la matriz es el segundo parámetro y devuelve una nueva matriz. Hay comentarios detallados sobre las variables de OldData.
/ *** Compruebe si el índice está fuera de límites* @param index*/ private void rangecheck (int index) {if (index> size || índice <0) {tire nuevo índiceutOfBoundsexception ("El indicador excede, index:" + index + ", size:" + tamaño); }}Si una búsqueda de subíndice es 1 /**
* Agregar elemento* Agregar el elemento especificado al final de la colección* @param e Elemento agregado* @return*/ public boolean add (E e) {EnsureCapacity (tamaño+1); elementData [tamaño] = e; tamaño ++; devolver verdadero; }Agregue un elemento, primero expanda la capacidad, asigne el valor y luego agregue el elemento uno. Tenga en cuenta que el tamaño del campo Tamaño+1 no se agrega uno. Aquí hay una operación aritmética, por lo que es necesario aumentarla más tarde.
/ *** Agregar elemento* Agregar elemento a la posición especificada* @param índice especificado índice índice índice elemento elemento* @param elemento* @return*/ public boolean add (int index, e elemento) {rangeCheck (index); Ensurecapacidad (tamaño+1); // Elemento ElementData que comienza desde la posición del índice y la longitud del índice de tamaño, // Copiar a una nueva matriz ElementData que comienza desde la posición del índice como índice+1. // Significa que el elemento actualmente en esta posición y todos los elementos posteriores se mueven directamente en una posición. System.ArrayCopy (ElementData, Index, ElementData, índice+1, índice de tamaño); elementData [index] = elemento; size ++; // Agregar elemento un retorno verdadero; }La diferencia aquí es System.ArrayCopy (ElementData, Index, ElementData, índice+1, índice de tamaño);
Este es un método interno de c. El texto original detallado tiene una explicación, por lo que no hablaré de ello aquí. Este es también el núcleo de toda la lista de matrices y también el principio de implementación interna de los matrices.copyOf ()
/*** Agregar todos los elementos* Agregue todos los elementos en la colección al final de esta lista en el orden de los elementos devueltos por el iterador de la colección especificada. * @param c * @return */ public boolean addall (colección <? extiende e> c) {objeto [] newelement = c.toarray (); int elementLength = Newelement.length; EnsureCapacity (size+elementLength); // Desde el subíndice de Newelement 0, ElementLength Elements, ElementData Size Subscript System.ArrayCopy (NewElement, 0, ElementData, Size, ElementLength); tamaño+= elementLength; return ElementLength! = 0; }Básicamente, otros métodos solo realizan diferentes procesos de acuerdo con diferentes situaciones, como pasar objetos de datos a través de la interfaz y obtener una longitud para la expansión, y copiar los datos en una nueva matriz utilizando el sistema y la arraycopy.
/ *** Especifique la posición, agregue todos los elementos* @Param Insertar Insertar el índice de posición* @param c Elementos insertados colección* @return*/ public boolean addall (int index, colección <? Extiende e> c) {if (índice> size || Índice <0) {tire nuevo índiceOutOfBoundsexception ("índice:" + índice + size: " + size); } Objeto [] NewElement = C.ToArray (); int elementLength = Newelement.length; EnsureCapacity (size+elementLength); int numMoved = size-index; // juzga si la posición de inserción está en el medio de la matriz if (numMoved> 0) {// mueve todos los elementos detrás de la posición de inserción del índice hacia atrás // inserta los elementos nummados que comienzan desde el índice de índice índice de índice Índice+elementlength del sistema de datos de elementos. } // Agregar ElementLength en NewElement de 0 a la posición donde el índice ElementData comienza el sistema. tamaño += elementLength; return ElementLength! = 0; } / ** * Especifique el valor del índice * @param índice * @param elemento * @return * / public e set (int index, e element) {rangeCheck (index); E Oldelement = (e) ElementData [índice]; elementData [index] = elemento; devolver el viejo vientre; } / ** * Obtenga el valor basado en el índice * @param índice * @return * / public e get (int index) {rangeCheck (index); return (e) elementData [índice]; } / *** eliminar elemento según el subíndice* @param index* / public e remove (int index) {rangeCheck (index); E Oldelement = (e) ElementData [índice]; / ** El número de elementos después del subíndice eliminado*/ int numMoved = size-Index-1; // Si se mueve dentro del rango de matriz if (numMoved> 0) System.ArrayCopy (ElementData, index+1, elementData, index, numMoved); // eliminar elementData [-size] = null; devolver el viejo vientre; } /** * Eliminar según el elemento * @param obj * @return * /public boolean remove (objus obj) {// arrayList permite nulo, por lo que el procesamiento de juicio también debe realizarse si (obj == null) {for (int index = 0; index <size; index ++) {if (elementData [index] ==) {eliminar (index); devolver verdadero; }}} else {for (int index = 0; index <size; index ++) {if (obj.equals (elementData [index])) {remove (index); devolver verdadero; }}} return false; } / *** Eliminar elementos en el rango especificado de acuerdo con el subíndice* @param fromindex start* @param toindex end* / proteged void removerange (int fromindex, int toindex) {rangeCheck (fromindex); Rangecheck (toindex); // El número de elementos a moverse int numMoved = size - toindex; // Mueve el elemento detrás de Oindex a Fromindex System.ArrayCopy (elementData, ToIndex, ElementData, FromIdex, NumMoved); // el número de elementos a eliminar int newsize = size- (toindex-fromindex); while (size! = Newsize) {elementData [-size] = null; }} / *** Ajuste la capacidad de matriz a la capacidad real* / public void Trimtosize () {int longitud = elementData.length; if (size <leng) {object [] old = elementData; elementData = arrays.copyOf (elementData, size); }} / *** Convertir elementos de colección en matriz* @return* / public object [] toArray () {return arrays.copyOf (elementData, size); } public <t> t [] ToArray (t [] a) {if (a.length <size) {return (t []) arrays.copyOf (elementData, size, a.getClass ()); } // Copiar el elemento de colección en la matriz asystem.ArrayCopy (ElementData, 0, a, 0, tamaño); if (a.length> size) {for (int index = size; index <a.length; index ++) {a [index] = null; }} return a; } Básicamente, se trata de operar la matriz y usar métodos C para asignar valores y moverlos. Puede ver el texto original en detalle. No hay muchos problemas en el texto original, excepto la variable privada, y el código puede ejecutarse perfectamente. La dificultad de esto y el uso de la variable OldData en el método de expansión serán los dos métodos de sistema, ArrayCopy y Arrayist.Copy () y el uso de la variable OldData en el método de expansión. Esta variable es realmente buena. Al principio, no sabía por qué lo usé así, y lo explicaré al final del texto original.
Lo anterior es una explicación de ejemplo de la implementación de Java ArrayList presentada por el editor. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje. El editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin Network!