Lista de matriz
La implementación subyacente es una matriz, que tiene una alta eficiencia para acceder a elementos (consulta rápida, inserción lenta, modificación y eliminación de elementos)
En comparación con LinkedList, es eficiente, pero seguro de hilo.
ArrayList Array es una matriz mutable que puede acceder a todos los elementos, incluidos NULL
La implementación subyacente se realiza utilizando matrices
objeto transitorio [] elementData;
Método de construcción
Private static final int default_capacity = 10; objeto final estático privado [] vacía_elementData = {}; objeto final estático privado [] defaultcapacity_empty_elementData = {}; objeto transitorio [] elementData; private int size; // Construye una lista vacía pública ArrayList () {this.elementData = defaultCapacity_Empty_elementData; } // Construye una lista vacía de la capacidad inicial especificada pública ArrayList (int InitialCapacity) {if (InitialCapacity> 0) {this.ElementData = new Object [InitialCapacity]; } else if (inicialCapacity == 0) {this.elementData = vacía_elementData; } else {tirar nueva ilegalArgumentException ("Capacidad ilegal:"+ InicialCapacity); }} // Construye una lista de elementos de recolección especificados, que se organizan en el orden de retorno iterativo de los elementos de conexión, Public ArrayList (Collection <? Extends e> c) {elementData = C.ToArray (); if ((size = elementData.length)! = 0) {// C.ToArray podría (incorrectamente) no devolver objeto [] (ver 6260652) if (elementData.getClass ()! = Object []. Class) ElementData = Arrays.CopyOf (ElementData, Size, Object []. Class); } else {// Reemplazar con una matriz vacía. this.ElementData = vacía_elementData; }}almacenamiento
// El elemento en la posición especificada de la lista se reemplaza por elemento, y el elemento original en esa posición se devuelve public e set (int index, e elemento) {rangeCheck (index); // Verifique la capacidad y el lanzamiento de la matriz: indexOutoFboundSexception e OldValue = elementData (índice); elementData [index] = elemento; devolver OldValue; } // Agregue el elemento especificado al final de la lista public boolean add (e e) {setureCapacityInternal (tamaño + 1); // expansión de matriz elementdata [size ++] = e; devolver verdadero; } // Agregue el elemento en la posición especificada de la lista public boolean add (e e) {setureCapacityInternal (size ++] = e; return true;} // Agregue el elemento en la posición especificada de la lista public void add (int index, e elemento) {rangechEdForAdd (index); assureCapacityInternernal (size+1); // modements modementCount: ////////// / / / ///////////xeury say) SRCPRO: Posición de inicio en la matriz de origen // Dest: Array de destino, DestPost: Inicie la matriz de destino, Longitud: Número de elementos de matriz a copiar// Mueva los elementos actualmente en esta posición y todos los elementos posteriores a la posición de la posición del Índice. Elementos en la conexión al final de la lista, y los elementos están en el orden devuelto por el iterador de la conexión boolean addall (colección <? ElementData, tamaño, numNew); Entre los incrementados (size + numNew);Leer
// Eliminar el elemento en la posición especificada de esta lista public e remove (int index) {rangeCheck (index); ModCount ++; E OldValue = elementData (índice); int numMoved = tamaño - índice - 1; if (numMoved> 0) System.ArrayCopy (ElementData, índice+1, elementData, index, numMoved); elementData [-size] = null; // claro para dejar que GC haga su trabajo devolver OldValue; } // Eliminar un elemento en esta lista Public Boolean Remete (Object O) {if (O == NULL) {for (int index = 0; index <size; index ++) if (elementData [index] == null) {fastremove (index); devolver verdadero; }} else {for (int index = 0; index <size; index ++) if (o.equals (elementData [index])) {fastremove (index); devolver verdadero; }} return false; } private void fastremove (int index) {modcount ++; int numMoved = tamaño - índice - 1; if (numMoved> 0) System.ArrayCopy (ElementData, índice+1, elementData, index, numMoved); elementData [-size] = null; // claro para dejar que GC haga su trabajo}Expansión de la matriz
Cada vez que se agrega un elemento a una matriz, es necesario verificar si el número de elementos excede la longitud de la matriz actual después de agregar elementos. Si excede la longitud, la matriz se ampliará para satisfacer las necesidades de agregar datos.
public void setureCapacity (int mincapacity) {int minexpand = (elementData! = defaultCapacity_empty_elementData)? 0: default_capacity; if (mincapacity> minexpand) {asegurarxplicitcapacity (mincapacity); }} private void setureCapacityInternal (int mincapacity) {if (elementData == defaultcapacity_empty_elementData) {mincapacity = math.max (default_capacity, mincapacity); } asegurar EXUSEXPICITCAPACCID (minCapacity); } private void aseSexplicitCapacity (int mincapacity) {modCount ++; // 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 + (OldCapacity >> 1); if (newCapacity - mincapacity <0) newCapacity = mincapacity; if (newCapacity - max_array_size> 0) newCapacity = HugeCapacity (mincapacity); // La mincapacidad generalmente está cerca del tamaño, por lo que esta es una victoria: elementData = arrays.copyOf (elementData, newCapacity); } private static int hugecapacity (int mincapacity) {if (mincapacity <0) // desbordamiento tirar nueva outOfMemoryError (); return (mincapacity> max_array_size)? Integer.max_value: max_array_size; }ArrayList escrita a mano
clase pública myArrayList /*Implementa la lista <E>* /{objeto transitorio privado [] elementData; tamaño privado int; // número de elementos public myArRayList () {this (10); } public myArrayList (int InitialCapacity) {if (InitialCapacity <0) {try {Throw New Exception (); } catch (Exception e) {E.PrintStackTrace (); }} elementData = nuevo objeto [InicialCapacity]; } public int size () {return size; } public boolean isEtimty () {return size == 0; } // Eliminar el objeto de acuerdo con el índice public void eliminar (int index) lanza la excepción {rangeCheck (index); int numMoved = size-index-1; if (numMoved> 0) {System.ArrayCopy (elementData, index+1, elementData, index, numMoved); } elementData [-size] = null; } // Eliminar el objeto public boolean Remete (object obj) arroja excepción {para (int i = 0; i <size; i ++) {if (get (i) .equals (obj)) {eliminar (i); } return verdadero; } return verdadero; } // Modificar el conjunto de objetos públicos del elemento (int index, object obj) lanza la excepción {rangeCheck (index); Objeto OldValue = elementData [index]; elementData [index] = obj; devolver OldValue; } // Inserte el elemento en la posición especificada public void add (int index, object obj) lanza la excepción {rangeCheck (index); EnsureCapacity (); System.ArrayCopy (ElementData, Index, ElementData, índice+1, índice de tamaño); elementData [index] = obj; tamaño ++; } public void add (objeto objeto) {EnsureCapacity (); /*elementData [size] = objeto; size ++;*/ elementData [size ++] = object; // Asignar valor primero, luego aumentar usted mismo} Public Object get (int index) lanza la excepción {rangeCheck (índice); return ElementData [índice]; } public void rangeCheck (int index) lanza la excepción {if (index <0 || index> = size) {throw nueva excepción (); }} // expandir public void setureCapacity () {// expansión de matriz y copia de contenido if (size == elementData.length) {// elementData = nuevo objeto [size*2+1]; Escriba de esta manera el contenido en la matriz original se pierde objeto [] newArray = nuevo objeto [tamaño*2+1]; // Copiar el contenido en la matriz/*for (int i = 0; i <newarray.length; i ++) {newArray [i] = elementData [i]; }*/ System.arrayCopy (elementData, 0, newArray, 0, elementData.length); elementData = newArray; }} // prueba public static void main (string [] args) {myArRayList myArrayList = new MyArRayList (3); myArrayList.Add ("111"); myArrayList.Add ("222"); myArrayList.Add ("333"); myArrayList.Add ("444"); myArrayList.Add ("555"); intente {myArrayList.remove (2); myArrayList.Add (3, "nuevo valor"); myArrayList.set (1, "modificar"); } Catch (Exception e1) {// TODO Bloque de captura automática e1.printstackTrace (); } System.out.println (myArrayList.Size ()); for (int i = 0; i <myArrayList.size (); i ++) {try {system.out.println (myArrayList.get (i)); } catch (Exception e) {E.PrintStackTrace (); }}}}