Comparação do vetor Java e Arraylist
Hoje, estudei os códigos de origem do vetor e do Arraylist e aprofundei minha compreensão dessas duas classes.
Existem três classes implementadas na interface da lista: Arraylist, Vector e LinkedList. Não vou dizer muito sobre o LinkedList, geralmente é usado para manter a ordem de inserção de dados.
Arraylist e Vector são implementados usando matrizes, e há três diferenças principais:
1. O vetor é multithread e seguro, enquanto o Arraylist não é. Isso pode ser visto no código -fonte. Muitos métodos na classe vetorial são modificados por sincronizados, o que leva à eficiência do vetor que não pode ser comparado com o Arraylist;
2. Ambos usam elementos lineares de armazenamento de espaço contínuo, mas quando o espaço é insuficiente, as duas classes são adicionadas de maneira diferente. Muitos internautas dizem que o vetor dobra o espaço original e a Arraylist aumenta o espaço original em 50%. De fato, isso é o mesmo. No entanto, ainda existem alguns problemas que podem ser vistos no código -fonte e serão analisados a partir do código -fonte posteriormente.
3. O vetor pode definir o fator de crescimento, mas o Arraylist não pode. Quando olhei para isso pela primeira vez, não entendi qual era o fator incremental. No entanto, entendi isso comparando os dois códigos de origem. Vamos primeiro olhar para os métodos de construção das duas classes:
Arraylist tem três métodos de construção:
public ArrayList (int InitialCapacity) // Construa uma lista vazia com a capacidade inicial especificada. public ArrayList () // Construa uma lista vazia com uma capacidade inicial de 10.
O vetor tem quatro construtores:
Public Vector () // Construa um vetor vazio usando o incremento de capacidade e capacidade inicial especificado igual a zero. Vector público (int InitialCapacity) // Construa um vetor vazio para fazer com que o tamanho de sua matriz de dados internos e seu incremento de capacidade padrão seja zero. vetor público (coleção <? estende e> c) // Construa um vetor que contém elementos no vetor público da coleção especificado (int inicialCaPacity, int CapacateIncrement) // Construa um vetor vazio usando os incrementos de capacidade e capacidade inicial especificados e capacidade
O vetor possui mais um método de construção do que a Arraylist. É isso mesmo, o método de construção do vetor público (int InitialCapacity, int CapacateIncrement). A capacidade de capacidade é o crescimento da capacidade, que é o fator de crescimento mencionado acima, que não está disponível no Arraylist.
Em seguida, poste duas classes para adicionar análise de código -fonte (versão JDK1.7):
// classe ArrayList Adicionar código fonte: public boolean add (e e) {surCapacityInternal (tamanho + 1); // incrementos modCount !! ElementData [size ++] = e; retornar true; } vazio privado EnsureCapacityInternal (int mincapacity) {modCount ++; // Código consciente do Overflow // Se após adicionar um elemento, o tamanho do novo contêiner é maior que a capacidade do contêiner, o valor não pode ser salvo. O espaço precisa ser expandido se (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); // O espaço de expansão aumenta em 50% (ou seja, 1,5 vezes o original) se (Newcapacity - MinCapacity <0) // se o contêiner ainda não for suficiente após a expansão, basta definir a pinheira para o tamanho do contêiner newCapacity = MinCapacity; if (newCapacity - max_array_size> 0) // Se o contêiner expandido for muito grande, execute o HugeCapacity newCapacity = hugecapacity (MinCapacity); // MinCapacity geralmente é próximo do tamanho, então isso é uma vitória: elementData = Arrays.copyof (ElementData, NewCapacity); } Adicione o código -fonte à classe vetorial:
public sincronizado boolean add (e e) {modCount ++; EnsureCapacityHelper (ElementCount + 1); ElementData [ElementCount ++] = e; retornar true; } vazio privado EnsureCapacityHelper (int mincapacity) {// Código consciente de overflow if (mincapacity - elementData.length> 0) Grow (MinCapacity); } Void privado Grow (int mincapacity) {// Código consciente do Overflow int OldCapacity = ElementData.length; int newCapacity = OldCapacity + ((CapacateIncrement> 0)? Capacidade -incremento: OldCapacity); /** Essa expansão da capacidade requer um julgamento: se o incremento da capacidade não for inicializado por 0, ou seja, a inicialização do construtor de vetor público (int InitialCapacity, Int Capacle -Ancrement), então a capacidade de expansão da capacidade é (capacidade antiga+capacidade de capacidade), que é o valor da capacidade original mais a capacidade; Se o incremento da capacidade não for definido, a capacidade após a expansão é (antiga capacidade+OldCapacity), que é o dobro da capacidade original. **/ if (NewCapacity - MinCapacity <0) newCapacity = MinCapacity; if (newCapacity - max_array_size> 0) newCapacity = hugecapacity (mincapacidade); ElementData = Arrays.copyof (ElementData, NewCapacity); }Através da análise, deve ser compreensível agora!
Obrigado pela leitura, espero que isso possa ajudá -lo. Obrigado pelo seu apoio a este site!