Java LinkedList

Neste tutorial, aprenderemos sobre o Java LinkedList em detalhes com a ajuda de exemplos.

O LinkedList A classe da estrutura de coleções Java fornece a funcionalidade da estrutura de dados de lista vinculada (lista duplamente vinculada).

Cada elemento em uma lista vinculada é conhecido como um nó . É composto por 3 campos:

Anterior - armazena um endereço do elemento anterior na lista. É null para o primeiro elemento
Próximo - armazena um endereço do próximo elemento na lista. É null para o último elemento
Dados - armazena os dados reais

Criando uma LinkedList Java

Aqui está como podemos criar listas vinculadas em Java:

LinkedList<Type> linkedList = new LinkedList<>();

Aqui, Digite indica o tipo de uma lista vinculada. Por exemplo,

// create Integer type linked list
LinkedList<Integer> linkedList = new LinkedList<>();

// create String type linked list
LinkedList<String> linkedList = new LinkedList<>();

Exemplo:Criar LinkedList em Java

import java.util.LinkedList;

class Main {
  public static void main(String[] args){

    // create linkedlist
    LinkedList<String> animals = new LinkedList<>();

    // Add elements to LinkedList
    animals.add("Dog");
    animals.add("Cat");
    animals.add("Cow");
    System.out.println("LinkedList: " + animals);
  }
}

Saída

LinkedList: [Dog, Cat, Cow]

No exemplo acima, criamos um LinkedList chamados animais .

Aqui, usamos o add() método para adicionar elementos ao LinkedList. Aprenderemos mais sobre o add() método mais adiante neste tutorial.

Trabalho de uma LinkedList Java

Os elementos em listas vinculadas não são armazenados em sequência. Em vez disso, eles estão espalhados e conectados por meio de links (Anterior e Próximo ).

Aqui temos 3 elementos em uma lista encadeada.

Cão - é o primeiro elemento que contém null como endereço anterior e o endereço de Gato como o próximo endereço
Gato - é o segundo elemento que contém um endereço de Dog como o endereço anterior e o endereço de Vaca como o próximo endereço
Vaca - é o último elemento que contém o endereço de Cat como o endereço anterior e null como o próximo elemento

Para saber mais, visite a estrutura de dados LinkedList.

Métodos de Java LinkedList

LinkedList fornece vários métodos que nos permitem realizar diferentes operações em listas vinculadas. Veremos quatro operadores LinkedList comumente usados neste tutorial:

Adicionar elementos
Elementos de acesso
Alterar elementos
Remover elementos

1. Adicionar elementos a uma LinkedList

Podemos usar o add() método para adicionar um elemento (nó) no final do LinkedList. Por exemplo,

import java.util.LinkedList;

class Main {
  public static void main(String[] args){
    // create linkedlist
    LinkedList<String> animals = new LinkedList<>();

    // add() method without the index parameter
    animals.add("Dog");
    animals.add("Cat");
    animals.add("Cow");
    System.out.println("LinkedList: " + animals);

    // add() method with the index parameter
    animals.add(1, "Horse");
    System.out.println("Updated LinkedList: " + animals);
  }
}

Saída

LinkedList: [Dog, Cat, Cow]
Updated LinkedList: [Dog, Horse, Cat, Cow]

No exemplo acima, criamos uma LinkedList chamada animals . Aqui, usamos o add() método para adicionar elementos a animais .

Observe a afirmação,

animals.add(1, "Horse");

Aqui, usamos o número de índice parâmetro. É um parâmetro opcional que especifica a posição onde o novo elemento é adicionado.

Para saber mais sobre como adicionar elementos ao LinkedList, visite o programa Java para adicionar elementos ao LinkedList.

2. Acessar elementos LinkedList

O get() O método da classe LinkedList é usado para acessar um elemento da LinkedList. Por exemplo,

import java.util.LinkedList;

class Main {
  public static void main(String[] args) {
    LinkedList<String> languages = new LinkedList<>();

    // add elements in the linked list
    languages.add("Python");
    languages.add("Java");
    languages.add("JavaScript");
    System.out.println("LinkedList: " + languages);

    // get the element from the linked list
    String str = languages.get(1);
    System.out.print("Element at index 1: " + str);
  }
}

Saída

LinkedList: [Python, Java, JavaScript]
Element at index 1: Java

No exemplo acima, usamos o get() método com parâmetro 1 . Aqui, o método retorna o elemento no índice 1 .

Também podemos acessar elementos do LinkedList usando o iterator() e o listIterator() método. Para saber mais, visite o programa Java para acessar elementos de LinkedList.

3. Alterar elementos de uma LinkedList

O set() método de LinkedList A classe é usada para alterar elementos da LinkedList. Por exemplo,

import java.util.LinkedList;

class Main {
  public static void main(String[] args) {
    LinkedList<String> languages = new LinkedList<>();

    // add elements in the linked list
    languages.add("Java");
    languages.add("Python");
    languages.add("JavaScript");
    languages.add("Java");
    System.out.println("LinkedList: " + languages);

    // change elements at index 3
    languages.set(3, "Kotlin");
    System.out.println("Updated LinkedList: " + languages);
  }
}

Saída

LinkedList: [Java, Python, JavaScript, Java]
Updated LinkedList: [Java, Python, JavaScript, Kotlin]

No exemplo acima, criamos uma LinkedList com nomes de idiomas. Observe a linha,

languages.set(3, "Kotlin");

Aqui, o set() O método altera o elemento no índice 3 para Kotlin .

4. Remover elemento de uma LinkedList

O remove() método do LinkedList A classe é usada para remover um elemento da LinkedList. Por exemplo,

import java.util.LinkedList;

class Main {
  public static void main(String[] args) {
    LinkedList<String> languages = new LinkedList<>();

    // add elements in LinkedList
    languages.add("Java");
    languages.add("Python");
    languages.add("JavaScript");
    languages.add("Kotlin");
    System.out.println("LinkedList: " + languages);

    // remove elements from index 1
    String str = languages.remove(1);
    System.out.println("Removed Element: " + str);

    System.out.println("Updated LinkedList: " + languages);
  }
}

Saída

LinkedList: [Java, Python, JavaScript, Kotlin]
Removed Element: Python
New LinkedList: [Java, JavaScript, Kotlin]

Aqui, o remove() O método usa o número do índice como parâmetro. E remove o elemento especificado pelo número de índice.

Para saber mais sobre como remover elementos do linkedlist, visite o programa Java para remover elementos do LinkedList.

Outros métodos

Métodos	Descrição
`contains()`	verifica se LinkedList contém o elemento
`indexOf()`	retorna o índice da primeira ocorrência do elemento
`lastIndexOf()`	retorna o índice da última ocorrência do elemento
`clear()`	remove todos os elementos da LinkedList
`iterator()`	retorna um iterador para iterar sobre LinkedList

LinkedList como Deque e Queue

Desde o LinkedList classe também implementa a interface Queue e Deque, ela também pode implementar métodos dessas interfaces. Aqui estão alguns dos métodos comumente usados:

Métodos	Descrições
`addFirst()`	adiciona o elemento especificado no início da lista encadeada
`addLast()`	adiciona o elemento especificado no final da lista vinculada
`getFirst()`	retorna o primeiro elemento
`getLast()`	retorna o último elemento
`removeFirst()`	remove o primeiro elemento
`removeLast()`	remove o último elemento
`peek()`	retorna o primeiro elemento (head) da lista encadeada
`poll()`	retorna e remove o primeiro elemento da lista vinculada
`offer()`	adiciona o elemento especificado no final da lista vinculada

Exemplo:Java LinkedList como fila

import java.util.LinkedList;
import java.util.Queue;

class Main {
  public static void main(String[] args) {
    Queue<String> languages = new LinkedList<>();

    // add elements
    languages.add("Python");
    languages.add("Java");
    languages.add("C");
    System.out.println("LinkedList: " + languages);

    // access the first element
    String str1 = languages.peek();
    System.out.println("Accessed Element: " + str1);

    // access and remove the first element
    String str2 = languages.poll();
    System.out.println("Removed Element: " + str2);
    System.out.println("LinkedList after poll(): " + languages);

    // add element at the end
    languages.offer("Swift");
    System.out.println("LinkedList after offer(): " + languages);
  }
}

Saída

LinkedList: [Python, Java, C]
Accessed Element: Python
Removed Element: Python
LinkedList after poll(): [Java, C]
LinkedList after offer(): [Java, C, Swift]

Exemplo:LinkedList como Deque

import java.util.LinkedList;
import java.util.Deque;

class Main {
  public static void main(String[] args){
    Deque<String> animals = new LinkedList<>();

    // add element at the beginning
    animals.add("Cow");
    System.out.println("LinkedList: " + animals);

    animals.addFirst("Dog");
    System.out.println("LinkedList after addFirst(): " + animals);

    // add elements at the end
    animals.addLast("Zebra");
    System.out.println("LinkedList after addLast(): " + animals);

    // remove the first element
    animals.removeFirst();
    System.out.println("LinkedList after removeFirst(): " + animals);

    // remove the last element
    animals.removeLast();
    System.out.println("LinkedList after removeLast(): " + animals);
  }
}

Saída

LinkedList: [Cow]
LinkedList after addFirst(): [Dog, Cow]
LinkedList after addLast(): [Dog, Cow, Zebra]
LinkedList after removeFirst(): [Cow, Zebra]
LinkedList after removeLast(): [Cow]

Iterando por LinkedList

Podemos usar o loop for-each Java para iterar por LinkedList. Por exemplo,

import java.util.LinkedList;

class Main {
    public static void main(String[] args) {
        // Creating a linked list
        LinkedList<String> animals = new LinkedList<>();
        animals.add("Cow");
        animals.add("Cat");
        animals.add("Dog");
        System.out.println("LinkedList: " + animals);

        // Using forEach loop
        System.out.println("Accessing linked list elements:");
        for(String animal: animals) {
            System.out.print(animal);
            System.out.print(", ");
        }
    }
}

Saída

LinkedList: [Cow, Cat, Dog]
Accessing linked list elements:
Cow, Cat, Dog,

LinkedList vs. Lista de matrizes

Tanto o Java ArrayList quanto o LinkedList implementa o List interface do Collections estrutura. No entanto, existe alguma diferença entre eles.

LinkedList	Lista de Matriz
Implementa `List` , `Queue` e `Deque` interfaces.	Implementa `List` interface.
Armazena 3 valores (endereço anterior , dados, e próximo endereço ) em uma única posição.	Armazena um único valor em uma única posição.
Fornece a implementação da lista duplamente vinculada.	Fornece uma implementação de matriz redimensionável.
Sempre que um elemento é adicionado, `prev` e `next` endereço são alterados.	Sempre que um elemento é adicionado, todos os elementos após essa posição são deslocados.
Para acessar um elemento, precisamos iterar desde o início até o elemento.	Pode acessar elementos aleatoriamente usando índices.

Observação :Também podemos criar uma LinkedList usando interfaces em Java. Por exemplo,

// create linkedlist using List
List<String> animals1 = new LinkedList<>();

// creating linkedlist using Queue
Queue<String> animals2 = new LinkedList<>();

// creating linkedlist using Deque
Deque<String> animals3 = new LinkedList<>();

Aqui, se a LinkedList for criada usando uma interface, não podemos usar métodos fornecidos por outras interfaces. Ou seja, animais1 não pode usar métodos específicos para Queue e Deque interfaces.

Interface Java Deque Java Array Deque

Java