Arraylist
A implementação subjacente é uma matriz, que tem alta eficiência no acesso a elementos (consulta rápida, inserção lenta, modificação e exclusão de elementos)
Comparado ao LinkedList, é eficiente, mas seguro para threads.
Arraylist Array é uma matriz mutável que pode acessar todos os elementos, incluindo NULL
A implementação subjacente é feita usando matrizes
objeto transitório [] elementData;
Método de construção
private estático final int default_capacity = 10; objeto final estático privado [] emailt_elementData = {}; objeto final estático privado [] defaultCapacity_empty_elementData = {}; objeto transitório [] elementData; private int size; // Construa uma lista vazia public ArrayList () {this.ElementData = defaultCapacity_empty_ElementData; } // Construa uma lista vazia da capacidade inicial especificada public ArrayList (int InitialCapacity) {if (InitialCapacity> 0) {this.ElementData = new Object [InitialCapacity]; } else if (InitialCapacity == 0) {this.ElementData = vazio_ElementData; } else {lança nova ilegalArgumentException ("Capacidade ilegal:"+ InitialCapacidade); }} // Construa uma lista de elementos de coleta especificados, que são organizados na ordem de retorno iterativo dos elementos de conexão Public ArrayList (coleção <? Extende e> c) {elementData = c.toarray (); if ((size = elementData.length)! = 0) {// c.toArray pode (incorretamente) não retornar objeto [] (consulte 6260652) if (elementData.getclass ()! = objeto []. classe) elementData = Arrays.copy de (elementData, tamanho, objeto []. Classe); } else {// substitua por matriz vazia. this.ElementData = emaillement_elementData; }}armazenar
// O elemento na posição especificado da lista é substituído pelo elemento, e o elemento original nessa posição é retornado e definido E (Int Index, E elemento) {Rangecheck (index); // Verifique a capacidade da matriz e jogue: indexOutOfBoundSexception e OldValue = elementData (index); elementData [index] = elemento; retornar OldValue; } // Adicione o elemento especificado no final da lista public boolean add (e e) {securecapacityInternal (tamanho + 1); // Expansão de matriz ElementData [size ++] = e; retornar true; } // Adicione o elemento na posição especificada da lista pública booleana add (e e) {securecapacityInternal (size ++] = e; retorna true;} // Adicione o elemento na posição especificada da lista public void (int index, e elemento e) {rangecheckfordd (índice); surcapacacityInnalthSal (e elemento) {Rangecheckford (Índice); surCapacacityInnaldSal (e elemento) {Rangecheckford); SrcPro: Posição Iniciar na matriz de origem // Dest: Matriz de destino, Destpost: Iniciar a posição da matriz de alvo, comprimento: Número de elementos da matriz a ser copiado // Mova os elementos atualmente nessa posição e todos os elementos subsequentes de um elemento de posição); Na conexão, no final da lista, e os elementos estão na ordem retornada pela conexão Public Boolean Addall (coleção <? ElementData, tamanho, tamanho); segurar -se (size + numMoved INDMOVED);Ler
// Remova o elemento na posição especificada desta lista pública e remove (int index) {Rangecheck (index); modCount ++; E OldValue = ElementData (índice); int numMoved = size - índice - 1; if (numMoved> 0) System.arrayCopy (ElementData, Index+1, ElementData, Index, numMoved); elementData [-size] = null; // Limpe para permitir que o GC faça seu trabalho retornar o OldValue; } // Remova um elemento nesta lista Public boolean Remover (objeto o) {if (o == null) {for (int index = 0; index <size; index ++) if (elementData [index] == null) {fastremove (index); retornar true; }} else {for (int index = 0; index <size; index ++) if (o.equals (elementData [index])) {fastremove (index); retornar true; }} retornar false; } private void fastremove (int index) {modCount ++; int numMoved = size - índice - 1; if (numMoved> 0) System.arrayCopy (ElementData, Index+1, ElementData, Index, numMoved); elementData [-size] = null; // Limpe para deixar o GC fazer seu trabalho}Expansão da matriz
Sempre que um elemento é adicionado a uma matriz, é necessário verificar se o número de elementos excede o comprimento da matriz atual após a adição de elementos. Se exceder o comprimento, a matriz será expandida para atender às necessidades de adicionar dados.
public void eguraCapacity (int mincapacity) {int minexpand = (elementData! = defaultCapacity_empty_elementData)? 0: default_capacity; if (mincapacity> minexpand) {garantirexplicitCapacity (MinCapacity); }} vazio privado ecrecapacityInternal (int mincapacity) {if (elementData == defaultCapacity_empty_ElementData) {mincapacity = Math.max (default_capacity, MinCapacity); } garantirexplicitCapacity (Mincapacity); } void privado garantirexplicCapacity (int mincapacity) {modCount ++; // Código consciente de transbordamento if (Mincapacity - ElementData.Length> 0) Grow (MinCapacity); } Void privado Grow (int mincapacity) {// Código consciente do Overflow int OldCapacity = ElementData.length; int newCapacity = OldCapacity + (OldCapacity >> 1); if (newCapacity - MinCapacity <0) newCapacity = Mincapacity; if (newCapacity - max_array_size> 0) newCapacity = hugecapacity (mincapacidade); // MinCapacity geralmente é próximo do tamanho, então isso é uma vitória: elementData = Arrays.copyof (ElementData, NewCapacity); } private estático int hugeCapacity (int mincapacity) {if (mincapacity <0) // Overflow lança novo outOfMemoryError (); Return (Mincapacity> max_array_size)? Integer.max_value: max_array_size; }Arraylist manuscrito
public class MyArrayList /*Iplementos List <E>* /{objeto transitório privado [] elementData; Tamanho privado int; // número de elementos public myArrayList () {this (10); } public MyArrayList (int InitialCapacity) {if (InitialCapacity <0) {try {throw New Exception (); } catch (Exceção e) {e.printStackTrace (); }} elementData = novo objeto [InitialCapacity]; } public int size () {Tamanho do retorno; } public boolean isEmpty () {return size == 0; } // Exclua o objeto de acordo com o índice public void Remover (int index) lança a exceção {Rangecheck (index); int numMoved = size-index-1; if (numMoved> 0) {System.ArrayCopy (ElementData, Index+1, ElementData, Index, numMoved); } elementData [-size] = null; } // exclua o objeto public boolean remove (objeto obj) lança exceção {for (int i = 0; i <tamanho; i ++) {if (get (i) .equals (obj)) {remove (i); } retornar true; } retornar true; } // Modificar o elemento Public Object Set (Int Index, Object Obj) lança exceção {Rangecheck (index); Objeto OldValue = elementData [index]; elementData [index] = obj; retornar OldValue; } // Insira o elemento na posição especificada public void add (índice int, object obj) lança a exceção {rangecheck (index); segurecapacity (); System.ArrayCopy (ElementData, Index, ElementData, Index+1, Size-Index); elementData [index] = obj; tamanho ++; } public void add (objeto objeto) {securecapacity (); /*elementData [size] = objeto; tamanho ++;*/ elementData [size ++] = object; // Atribua o valor primeiro e depois aumente} objeto público get (int index) lança exceção {rangecheck (index); retornar elementData [index]; } public void rangecheck (int index) lança exceção {if (index <0 || index> = size) {lança nova exceção (); }} // Expandir public void eSureCapacity () {// Expansão de matriz e cópia de conteúdo if (size == elementData.length) {// elementData = new Object [size*2+1]; Escreva dessa maneira, o conteúdo da matriz original é perdido objeto [] newArray = novo objeto [tamanho*2+1]; // copie o conteúdo na matriz/*para (int i = 0; i <newArray.length; i ++) {newArray [i] = elementData [i]; }*/ System.ArrayCopy (ElementData, 0, NewArray, 0, ElementData.Length); elementData = newArray; }} // Teste 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"); tente {MyArrayList.Remove (2); MyArrayList.add (3, "Novo valor"); MyArrayList.Set (1, "Modify"); } catch (Exceção E1) {// TODO GATO GENERATO AUTOMENTADO E1.PRINTSTACKTRACE (); } System.out.println (MyArrayList.size ()); para (int i = 0; i <myArrayList.size (); i ++) {try {System.out.println (MyArrayList.get (i)); } catch (Exceção e) {e.printStackTrace (); }}}}