Interface de lista
A interface da lista estipula: Os elementos armazenados no container são ordenados e podem ser repetidos.As
principais classes de implementação para implementá-lo são ArrayList e LinkedList, e quase não há Vector.
ArrayList
Realização interna
- Em primeiro lugar, o interno é implementado com uma matriz , uma matriz Object chamada elementData
- Ao criar um ArrayList sem parâmetros, a atribuição inicial é um array vazio e a capacidade será alocada apenas quando os elementos forem realmente adicionados.
(Ou seja, ao adicionar o primeiro elemento à matriz, a capacidade da matriz é expandida para 10)
Expansão A expansão do
container sempre foi o foco
da expansão de ArrayList é colocada na lógica do método add, ou seja, quando você adiciona elementos, você só se preocupa com a expansão.
添加元素（add）：
判断扩容（ensureCapacityInternal）：//确保容量够，不会越界
如果当前数组是空数组：//刚刚创建，尚未添加元素
预期容量改为10 //当存储元素时，至少是要有10个大小的容量的
否则预期容量是当前size+1
尝试扩容（ensureExplicitCapacity）：
如果预期容量大于现在数组的大小：
扩容1.5倍（grow）//近似，位运算
添加元素
O texto acima é um resumo da lógica de adição de elementos ao método add. Antes de adicionar elementos, você precisa avaliar se a capacidade atual é suficiente e, se não for suficiente, você precisa expandir a capacidade.
método de cultivo
- A operação de expansão específica é o método de crescimento, onde operações de bits são usadas
- Se crescer, a capacidade esperada será transmitida, e será 1,5 vezes o tamanho máximo da capacidade anterior e a capacidade esperada (1 começa a atingir a capacidade esperada e mais tarde é 1,5 vez, isso também é bem compreendido)
- Se a capacidade esperada for maior do que MAX_ARRAY_SIZE, a capacidade é posicionada Integer.MAX_VALUE (MAX ·· é um valor constante)
Durante a expansão, o método Arrays.copyOf () é chamado, o que cria uma nova matriz internamente e, em seguida, chama o método System.arraycopy () para copiar o conteúdo da matriz antiga para a nova. Para realizar a operação de expansão.
E o método System.arraycopy (), na verdade a função é copiar uma parte da porção do array para outro array (que pode ser todo)
como para comparação: o primeiro porque o novo array, mais adequado para expansão
que geralmente é de Copiar para você mesmo, por isso é mais adequado para mover, como inserir (adicionar (xxx, índice)) que precisa ser movido
A expansão ativa é
devido à expansão 1,5 vezes (pode ser entendida como 0-10-15-22,5- ··· o grupo a seguir é de 1,5). Com este mecanismo, se o usuário precisar de uma grande quantidade de armazenamento, a expansão será executado muitas vezes, e cada vez que precisa ser expandido. Leva tempo O (n) para copiar o array, que é ineficiente.
Portanto, ArrayList também fornece um método para os usuários especificarem o tamanho da capacidade de expansão, reduzindo assim o número de expansões.
garantir a capacidade
Ao excluir o elemento especificado, o mesmo é verdadeiro. Você precisa chamar o método System.arraycopy () e, em seguida, mover o elemento começando no índice + 1 para o índice. A complexidade do tempo é O (n)
Serialização
Como o comprimento da matriz dentro de ArrayList é basicamente maior do que o tamanho do número real de elementos armazenados, não há necessidade de serializar a matriz interna como uma implementação durante a serialização, portanto, elementData é modificado com transiente.
E também escreveu o método writeObject e o método readObject para serializar apenas a parte da matriz preenchida com elementos.
Fail-Fast
ArrayList usa a variável modCount para registrar o número de vezes que a estrutura ArrayList mudou: adicionar ou excluir ou ajustar o tamanho da matriz (apenas modificar o valor do elemento não conta, mas a estrutura precisa ser modificada)
O
mecanismo fail-fast é usado principalmente para problemas de segurança de simultaneidade multi-threaded aqui.O mecanismo fail-fast é um mecanismo de erro na coleção java. Quando vários threads operam no conteúdo da mesma coleção, um evento fail-fast pode ocorrer. Por exemplo: quando um thread A percorre uma coleção por meio do iterador, se o conteúdo da coleção for alterado por outros threads; então, quando o thread A acessa a coleção, um ConcurrentModificationException será lançado e um evento fail-fast será gerado. (Da Enciclopédia Baidu)
Durante a iteração simultânea, julgue, se o modcount for modificado, ele pode ser encerrado diretamente,
Esta variável foi anteriormente modificada por volatile, mas agora jdk1.7 foi removido, porque eu acho que os pacotes simultâneos podem ser usados para simultaneidade.Isso ainda está reservado para uso de thread único.
LInkedList
Como uma classe de implementação List comumente usada, ela é muito usada.
- Interface List implementada e interface Deque
- Lista vinculada dupla
O que se segue é um pouco de sua lógica de método simples
adicionar método: adicionar nós à cauda
add://添加节点到尾部 linkLast://将节点加到尾部，此处需要判空
add (int index, E e): adiciona um nó à posição especificada
add(int index, E e): 如果是尾部（用长度和index来判断），linkLast 不是尾部，找到要插入的点（O(n)遍历到指定位置） 将其和输入传给linkBefore: 进行插入
addAll: insira a coleção no final da lista vinculada
1.检查index范围是否在size之内 2.toArray()方法把集合的数据存到对象数组中 3.得到插入位置的前驱和后继节点 4.遍历数据，将数据插入到指定位置
addFirst: adiciona um nó à cabeça
- O método linkFirst é chamado, a operação é muito simples, não há nada a dizer
addLast: o mesmo
get (int index): obtém o nó na posição especificada
- Isso é para chamar o método do nó
indexOf (Object o): Obtenha o índice de acordo com o objeto
- Percorra desde o início para encontrar o índice
lastIndexOf ：
- Atravesse o final para encontrar o índice
contém (Objeto o): Verifique se o objeto está na lista vinculada
- Use o índice para julgar
No geral, LinkedList é relativamente simples, e a diferença entre ele e ArrayList também é óbvia
. A implementação subjacente é diferente, se tem capacidade de acesso aleatório eficiente, se tem capacidade de inserção eficiente, eficiência de armazenamento, etc. comparações. Simples, não vou entrar em detalhes
Vetor
Não vou entrar em detalhes sobre isso. É semelhante a ArrayList. Também é realizado pelo array Object, e muitas palavras-chave sincronizadas são usadas nele, para que possa atender ao problema de segurança de multi-threading. Mas o desempenho é medíocre por causa disso.
Geralmente não use