Este artigo participou da atividade "Cerimônia de Criação do Recém-chegado" e iniciou o caminho da criação de Nuggets juntos

Coleção Java - Vector, LinkedList (interpretação do código-fonte JDK17)

Vetor

Implementação de estrutura de matriz, consulta rápida, adição e exclusão lentas, eficiência de execução lenta, segurança de thread

Exemplo

Por causa da semelhança entre Vector e ArrayList, coloquei a instância diretamente

package list;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;

public class demno2 {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("a");
        vector.add("b");
        vector.add("c");
        //直接看遍历
        Enumeration<String> elements = vector.elements();
        while (elements.hasMoreElements()){
            System.out.println(elements.nextElement());
        }
    }
}

复制代码

Lista vinculada

Implementação de estrutura de lista vinculada, adição e exclusão rápidas, consulta lenta 在这里插入图片描述

Método comum

Criar método

LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表
复制代码

O método 1.addFirst adiciona elementos ao cabeçalho

LinkedList<String> list1 = new LinkedList<>();
        list1.add("a1");
        list1.add("a2");
        list1.add("a3");
        list1.addFirst("n1");
        for (String x : list1) {
            System.out.println(x);
        }
复制代码

2. método addLast adiciona elementos no final

 LinkedList<String> list1 = new LinkedList<>();
        list1.add("a1");
        list1.add("a2");
        list1.add("a3");
        list1.addLast("b1");
        for (String x : list1) {
            System.out.println(x);
        }
复制代码

3. O método removeFirst remove os elementos do cabeçalho

 LinkedList<String> list1 = new LinkedList<>();
        list1.add("a1");
        list1.add("a2");
        list1.add("a3");
        list1.removeFirst();
        for (String x : list1) {
            System.out.println(x);
        }
复制代码

4. O método removeLast remove o elemento tail

LinkedList<String> list1 = new LinkedList<>();
        list1.add("a1");
        list1.add("a2");
        list1.add("a3");
        list1.removeLast();
        for (String x : list1) {
            System.out.println(x);
        }
复制代码

5. Método getFirst para obter o elemento head

LinkedList<String> list1 = new LinkedList<>();
        list1.add("a1");
        list1.add("a2");
        list1.add("a3");
        System.out.println(list1.getFirst());
复制代码

6. Método getLast para obter o elemento de cauda

LinkedList<String> list1 = new LinkedList<>();
        list1.add("a1");
        list1.add("a2");
        list1.add("a3");
        System.out.println(list1.getLast());
复制代码

Outros métodos

oferta booleana pública (E e)向链表末尾添加元素，返回是否成功，成功为true，失败为 false。
oferta booleana públicaPrimeiro (E e)头部插入元素，返回是否成功，成功为true，失败为false。
oferta booleana públicaLast(E e)尾部插入元素，返回是否成功，成功为true，失败为 false
public E removeFirst()删除并返回第一个元素
public E removeLast()删除并返回最后一个元素
público E enquete()删除并返回第一个元素
public E remover()删除并返回第一个元素
público E espiar()返回第一个元素
elemento público E()返回第一个元素
public E peekFirst()返回头部元素
public E peekLast()返回尾部元素

Faixa de uso da lista de tintas e da lista de matrizes

Use ArrayList nas seguintes situações:

Acesso frequente a um elemento em uma lista.
Basta adicionar e remover elementos do final da lista.

Use LinkedList nas seguintes situações:

Você precisa percorrer um loop para acessar determinados elementos na lista.
É necessário adicionar e excluir elementos frequentemente no início, no meio e no final da lista.

Interpretação do código-fonte

O tamanho do contêiner é padronizado para 0

transient int size = 0;
复制代码

nó principal

transient Node<E> first;
复制代码

nó de cauda

 transient Node<E> last;
复制代码

Construtor sem argumentos

Isso mesmo, construções sem argumentos são vazias

public LinkedList() {
    }
复制代码

Como adicionar elementos no LinkedList (método add)

public boolean add(E e) {
        linkLast(e);
        return true;
    }
    
void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
    
private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
复制代码

Vamos dar uma olhada

A primeira linha de add chama o método linkLast

A segunda linha Nfinal Node< E > l = last; obtém o último nó

Esta é a estrutura real

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
复制代码

A partir disso, podemos ver que o Node consiste em três blocos:

campo de dados do item
Nó< E > próximo Próximo Nó
Node< E > prev 前一个 Node

这是因为Java中没有（显）指针的概念，所以无法用地址的引用来对前一个Node和后一个Node进行寻址获取而是以这样一种形式链到了一起成了“三人帮“ 所以当你找到一个Node的时候也就找到了他相邻的两个Node

俗称一人犯罪连累邻里，连坐由此产生

第三行final Node< E > newNode = new Node<>(l, e, null)；创建一个新结点

这个新结点可以看出他的上一个结点是上面第二行的 l 结点，也就是最后一个结点，自己呢就是传入进来的e，而他没有尾节点，所以是null

第四行 last = newNode;让尾节点变成新结点

第五部分if判断

如果你是添加第一个元素，现在 l 就是空的那么

first = newNode;
复制代码

头节点就会获取新结点然后容器大小size+1，修改次数+1

如果你之前已经有元素了，这说明尾节点非空，那么 l 也是非空

l.next = newNode;
复制代码

那么 l 的下一个就是新的结点在这里插入图片描述