Visão geral do Arraylist:
O ArrayList é implementado com base em matrizes e é uma matriz dinâmica cuja capacidade pode crescer automaticamente, semelhante à memória de aplicativo dinâmica na linguagem C, que aumenta dinamicamente a memória.
A ArrayList não é segura por threads e só pode ser usada em um ambiente de tiro único. Em um ambiente multithread, você pode considerar o uso da função Coleções.
A ArrayList implementa a interface serializável, para suportar a serialização, pode ser transmitida por serialização, implementa a interface aleatória e suporta acesso aleatório rápido. De fato, é um acesso rápido através do número de série subscrito, implementa a interface clonável e pode ser clonado.
Cada instância da Arraylist tem uma capacidade, que se refere ao tamanho da matriz usada para armazenar elementos da lista. É sempre pelo menos igual ao tamanho da lista. À medida que os elementos são constantemente adicionados à lista de Array, sua capacidade também aumenta automaticamente. O crescimento automático trará uma recuperação de dados para a nova matriz; portanto, se você puder prever a quantidade de dados, poderá especificar sua capacidade ao construir uma lista de Array. Antes de adicionar um grande número de elementos, o aplicativo também pode usar a operação de segurança para aumentar a capacidade da instância do Arraylist, que pode reduzir o número de redistribuições incrementais.
Observe que essa implementação não é síncrona. Se vários threads acessarem uma instância do Arraylist ao mesmo tempo e pelo menos um dos threads modificar estruturalmente a lista, ele deve permanecer sincronizado externamente.
Vamos fazer um recorde e um resumo do Java Arraylist
classe pública ArrayList <E> { / *** elementos que armazenam a coleção** / objeto transitório privado [] elementData; / ** Tamanho do elemento*/ Tamanho privado int;Defina uma classe genérica, uma matriz de objeto e uma variável privada para registrar o número de elementos na coleção. Há uma variável privada adicional no texto original, e não sei o que usá -lo, e o autor não tem explicação ou mencionado. Tudo bem se eu não o usasse.
/ ** * Inicialize de acordo com o tamanho especificado * @param InitialCapacity */ public ArrayList (int InitialCapacity) {super (); if (InitialCapacity <= 0) {// Exceção Jogue novo ilegalArgumentException ("O parâmetro de inicialização não pode ser menor que 0"); } else {// inicialize a matriz this.ElementData = new Object [InitialCapacity]; }} / *** Inicialização padrão* / public ArrayList () {this (10); } /*** Inicialize de acordo com uma classe de coleta* @param c uma classe que deve herdar a interface de coleta* /public ArrayList (coleção <? Extende e> c) {// inicialize elementData = c.toArray (); size = elementData.length; // converte o tipo de objeto if (elementData.getClass ()! = Objeto []. Classe) {elementData = Arrays.copyof (elementData, tamanho, objeto []. Classe); }} 3 Métodos de inicialização, inicialize a matriz de acordo com o tamanho padrão, inicialize o tamanho fornecido e passe uma classe que herda a interface de coleção de coleta para a inicialização da atribuição de conversão
/ *** Coleção de expansão* @param mincapacity*/ public void EnsureCapacity (int mincapacity) {/ ** Tamanho atual da matriz*/ int OldCapacity = elementData.Length; Se (MinCapacity> OldCapacity) { /*** Embora o antigoData não seja usado, trata-se de gerenciamento de memória e o método da copy () não é um thread de threads*, que não é reciclado por elemento que o elemento do elemento, o que é o que é reciclado por elemento, quando o Methodies de Methodies, que não será reciclado por gc alocando a memória da Memory ElementData de ser invadida. * Quando o fim está saindo se, o ciclo antigo dos dados termina e é reciclado*/ objeto antigoData [] = elementData; int newCapacity = (OldCapacity * 3)/2 + 1; // Aumentar 50%+1 if (newcapacity <mincapacity) newCapacity = MinCapacity; // Use Arrays.copyof para copiar os elementos da coleção e gerar um novo elemento da matriz = Arrays.copyof, NewCapacity); }}Este é um método central. A expansão do conjunto é realmente comparar a expansão da matriz e o tamanho da coleção de pinças para determinar se ela deve ser expandida. O método Arrays.copyof () é usado para expansão.
O texto original tem uma explicação detalhada. Este método copia o conteúdo do primeiro parâmetro para uma nova matriz. O tamanho da matriz é o segundo parâmetro e retorna uma nova matriz. Existem comentários detalhados sobre as variáveis do OldData.
/ *** Verifique se o índice está fora dos limites* @param Índice*/ private void Rangecheck (int index) {if (index> size || índice <0) {lança novo indexOutOfBoundSexception ("Indicador excede, índice:" + index + ", tamanho:" + tamanho); }}Se uma pesquisa subscrita é 1 /**
* Adicionar elemento* Adicione o elemento especificado ao final da coleção* @param e elemento adicionado* @return*/ public boolean add (e e) {surCapacity (size+1); elementData [size] = e; tamanho ++; retornar true; }Adicione um elemento, primeiro expanda a capacidade, atribua o valor e adicione o elemento um. Observe que o tamanho+1 tamanho de campo não é adicionado. Aqui está uma operação aritmética, por isso é necessário aumentá -la mais tarde.
/ *** Adicionar elemento* Adicionar elemento à posição especificada* @param índice especificado índice índice índice elemento elemento* elemento @param* @return*/ public boolean add (int index, e elemento) {rangecheck (index); segurança (tamanho+1); // elemento elementoData a partir da posição do índice e comprimento do tamanho-índice, // Copiar para uma nova matriz de elemento que a partir da posição do índice como índice+1. // significa que o elemento atualmente nesta posição e todos os elementos subsequentes são movidos à direita por uma posição. System.ArrayCopy (ElementData, Index, ElementData, Index+1, Size-Index); elementData [index] = elemento; tamanho ++; // Adicionar elemento um retorno true; }A diferença aqui é System.arrayCopy (ElementData, Index, ElementData, Index+1, Size-Index);
Este é um método interno de c. O texto original detalhado tem uma explicação, então não vou falar sobre isso aqui. Este também é o núcleo de toda a Arraylist e também o princípio de implementação interna de Arrays.copyof ()
/*** Adicione todos os elementos* Adicione todos os elementos na coleção ao final desta lista na ordem dos elementos retornados pelo iterador da coleção especificada. * @param c * @return */ public boolean addall (coleção <? estende e> c) {object [] newelement = c.toarray (); int elementLength = newElement.length; segurança (tamanho+elemento); // do subscrito do newelement 0, elementos elementLength, elementData size subscript system.arraycopy (newelement, 0, elementData, tamanho, elemento elemento); tamanho+= elementLength; Retornar elementLengngth! = 0; }Basicamente, outros métodos executam apenas processamento diferente de acordo com diferentes situações, como a passagem de objetos de dados através da interface e a obtenção de comprimento para expansão e copiar os dados em uma nova matriz usando o sistema e o Arraycopy.
/ *** Especifique a posição, adicione todos os elementos* @param Índice Inserir índice de posição* @param c coleta de elementos inseridos* @return*/ public boolean addall (int index, coleta <? Estende e> c) {if (index> size || Índice <0) {lança novo indexBoundSexception (":" Index + ", tamanho:") {throw threen + size); } Objeto [] newElement = c.toarray (); int elementLength = newElement.length; segurança (tamanho+elemento); int numMoved = size-index; // julgue se a posição de inserção está no meio da matriz se (nummoved> 0) {// mova todos os elementos por trás da posição de inserção do índice para trás // Insira os elementos nummoved que iniciam o índice de índice Índice no índice no índice+elementLength Position of ElementData Data System.arraycopy (ElementData, Índice, elementData, } // Adicione o elementLength no NewElement de 0 à posição em que o elemento Data Index inicia o System.ArrayCopy (NewElement, 0, ElementData, Index, ElementLength); tamanho += elementLength; Retornar elementLengngth! = 0; } / ** * Especifique o valor do índice * @param Índice * @param elemento * @return * / public e set (int index, e elemento) {rangecheck (index); E OldElement = (e) elementData [index]; elementData [index] = elemento; retornar o OldElement; } / ** * Obtenha o valor com base no índice * @param Índice * @return * / public e get (int index) {rangecheck (index); return (e) elementData [index]; } / *** Remova o elemento de acordo com o subscrito* @param Índice* / public e Remover (int index) {Rangecheck (index); E OldElement = (e) elementData [index]; / ** O número de elementos após o subscrito removido*/ int numMoved = size-index-1; // se for movido dentro do intervalo de matrizes se (numMoved> 0) System.arrayCopy (ElementData, Index+1, ElementData, Index, numMoved); // Remover elementData [-size] = null; retornar o OldElement; } /** * Remova de acordo com o elemento * @param obj * @return * /public boolean remove (objeto obj) {// ArrayList permite nulo; portanto, o processamento do julgamento também deve ser executado se (obj == null) {para (int index = 0; index <size; retornar true; }}} else {for (int index = 0; index <size; index ++) {if (obj.equals (elementData [index])) {remove (index); retornar true; }}} retorna false; } / *** Remova os elementos no intervalo especificado de acordo com o subscrito* @param fromIndex start* @param toIndex end* / removerange de void protegido (int arindex, int toIndex) {rangecheck (fromindex); Rangecheck (ToIndex); // o número de elementos a serem movidos int numMoved = size - toIndex; // mova o elemento para trás toIndex para FromIndex System.ArrayCopy (ElementData, ToIndex, ElementData, FromIndex, numMoved); // o número de elementos a serem removidos int newsize = size- (toIndex-fromindex); while (size! = newsize) {elementData [-size] = null; }} / *** Ajuste a capacidade da matriz para a capacidade real* / public void TRIMTOSIZE () {int Length = elementData.length; if (size <leng) {object [] old = elementData; elementData = Arrays.copyof (elementData, tamanho); }} / *** Converta elementos de coleta em 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 ()); } // Copie o elemento de coleta no array asystem.arraycopy (elementData, 0, a, 0, tamanho); if (a.Length> size) {for (int index = size; index <A.Length; index ++) {a [index] = null; }} retornar um; } Basicamente, trata -se de operar a matriz e usar os métodos C para atribuir valores e movê -los. Você pode visualizar o texto original em detalhes. Não há muitos problemas no texto original, exceto a variável privada, e o código pode ser executado perfeitamente. A dificuldade disso e o uso da variável antiga no método de expansão serão os dois métodos de sistema, Arraycopy e Arrayist.copy () e o uso da variável antiga no método de expansão. Essa variável é realmente boa. No começo, eu não sabia por que usei assim e explicarei no final do texto original.
O exposto acima é um exemplo de explicação da implementação do Java ArrayList apresentado a você pelo editor. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem. O editor responderá a tempo. Muito obrigado pelo seu apoio ao site da Wulin Network!