Java LinkedList

Lista enlazada de Java

En este tutorial, aprenderemos sobre Java LinkedList en detalle con la ayuda de ejemplos.

El LinkedList La clase del marco de colecciones de Java proporciona la funcionalidad de la estructura de datos de lista enlazada (lista doblemente enlazada).

Cada elemento de una lista enlazada se conoce como nodo . Consta de 3 campos:

Anterior - almacena una dirección del elemento anterior en la lista. Es null para el primer elemento
Siguiente - almacena una dirección del siguiente elemento en la lista. Es null para el último elemento
Datos - almacena los datos reales

Creación de una lista enlazada de Java

Así es como podemos crear listas enlazadas en Java:

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

Aquí, Escriba indica el tipo de una lista enlazada. Por ejemplo,

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

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

Ejemplo:Crear LinkedList en 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);
  }
}

Salida

LinkedList: [Dog, Cat, Cow]

En el ejemplo anterior, hemos creado un LinkedList animales con nombre .

Aquí, hemos usado el add() método para agregar elementos a LinkedList. Aprenderemos más sobre el add() más adelante en este tutorial.

Funcionamiento de una lista enlazada de Java

Los elementos de las listas enlazadas no se almacenan en secuencia. En cambio, están dispersos y conectados a través de enlaces (Anterior y Siguiente ).

Aquí tenemos 3 elementos en una lista enlazada.

Perro - es el primer elemento que contiene null como dirección anterior y la dirección de Cat como la próxima dirección
Gato - es el segundo elemento que contiene una dirección de Perro como la dirección anterior y la dirección de Vaca como la próxima dirección
Vaca - es el último elemento que contiene la dirección de Cat como la dirección anterior y null como el siguiente elemento

Para obtener más información, visite la Estructura de datos de LinkedList.

Métodos de Java LinkedList

LinkedList proporciona varios métodos que nos permiten realizar diferentes operaciones en listas enlazadas. Veremos cuatro operadores LinkedList de uso común en este tutorial:

Añadir elementos
Acceder a elementos
Cambiar elementos
Eliminar elementos

1. Añadir elementos a una LinkedList

Podemos usar el add() para agregar un elemento (nodo) al final de LinkedList. Por ejemplo,

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);
  }
}

Salida

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

En el ejemplo anterior, hemos creado una LinkedList llamada animals . Aquí, hemos usado el add() método para añadir elementos a animales .

Note la declaración,

animals.add(1, "Horse");

Aquí, hemos utilizado el número de índice parámetro. Es un parámetro opcional que especifica la posición donde se agrega el nuevo elemento.

Para obtener más información sobre cómo agregar elementos a LinkedList, visite el programa Java para agregar elementos a LinkedList.

2. Acceder a los elementos de LinkedList

El get() El método de la clase LinkedList se utiliza para acceder a un elemento de LinkedList. Por ejemplo,

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);
  }
}

Salida

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

En el ejemplo anterior, hemos utilizado el get() método con parámetro 1 . Aquí, el método devuelve el elemento en el índice 1 .

También podemos acceder a elementos de LinkedList usando el iterator() y el listIterator() método. Para obtener más información, visite el programa Java para acceder a los elementos de LinkedList.

3. Cambiar elementos de una lista enlazada

El set() método de LinkedList La clase se usa para cambiar elementos de LinkedList. Por ejemplo,

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);
  }
}

Salida

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

En el ejemplo anterior, hemos creado una LinkedList llamada languages. Fíjate en la línea,

languages.set(3, "Kotlin");

Aquí, el set() El método cambia el elemento en el índice 3 a Kotlin .

4. Quitar elemento de una LinkedList

El remove() método del LinkedList La clase se usa para eliminar un elemento de LinkedList. Por ejemplo,

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);
  }
}

Salida

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

Aquí, el remove() El método toma el número de índice como parámetro. Y elimina el elemento especificado por el número de índice.

Para obtener más información sobre cómo eliminar elementos de la lista enlazada, visite el programa Java para eliminar elementos de la lista enlazada.

Otros métodos

Métodos	Descripción
`contains()`	comprueba si LinkedList contiene el elemento
`indexOf()`	devuelve el índice de la primera aparición del elemento
`lastIndexOf()`	devuelve el índice de la última aparición del elemento
`clear()`	elimina todos los elementos de LinkedList
`iterator()`	devuelve un iterador para iterar sobre LinkedList

LinkedList como Deque y Queue

Desde el LinkedList class también implementa las interfaces Queue y Deque, también puede implementar métodos de estas interfaces. Estos son algunos de los métodos más utilizados:

Métodos	Descripciones
`addFirst()`	añade el elemento especificado al principio de la lista enlazada
`addLast()`	añade el elemento especificado al final de la lista enlazada
`getFirst()`	devuelve el primer elemento
`getLast()`	devuelve el último elemento
`removeFirst()`	elimina el primer elemento
`removeLast()`	elimina el último elemento
`peek()`	devuelve el primer elemento (cabeza) de la lista enlazada
`poll()`	devuelve y elimina el primer elemento de la lista enlazada
`offer()`	añade el elemento especificado al final de la lista enlazada

Ejemplo:Java LinkedList como cola

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);
  }
}

Salida

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

Ejemplo: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);
  }
}

Salida

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

Iterando a través de LinkedList

Podemos usar el bucle for-each de Java para iterar a través de LinkedList. Por ejemplo,

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(", ");
        }
    }
}

Salida

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

LinkedList vs. ArrayList

Tanto Java ArrayList como LinkedList implementa el List interfaz del Collections estructura. Sin embargo, existe alguna diferencia entre ellos.

Lista enlazada	Lista de matrices
Implementa `List` , `Queue` y `Deque` interfaces.	Implementa `List` interfaz.
Almacena 3 valores (dirección anterior , datos, y siguiente dirección ) en una sola posición.	Almacena un solo valor en una sola posición.
Proporciona la implementación de listas doblemente enlazadas.	Proporciona una implementación de matriz redimensionable.
Cada vez que se agrega un elemento, `prev` y `next` la dirección ha cambiado.	Cada vez que se agrega un elemento, todos los elementos después de esa posición se desplazan.
Para acceder a un elemento, necesitamos iterar desde el principio hasta el elemento.	Puede acceder aleatoriamente a elementos usando índices.

Nota :También podemos crear una LinkedList usando interfaces en Java. Por ejemplo,

// 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<>();

Aquí, si LinkedList se crea usando una interfaz, entonces no podemos usar métodos proporcionados por otras interfaces. Es decir, animales1 no puede usar métodos específicos de Queue y Deque interfaces.

Interfaz Java Deque Java ArrayDeque

Java