Programa Java para obtener elementos de una LinkedList

La lista enlazada es una estructura de datos lineal, en la que los elementos no se almacenan en las ubicaciones de memoria contiguas. Aquí, la tarea es obtener los elementos de una LinkedList.

1. Podemos usar el método get(int variable) para acceder a un elemento desde un índice específico de LinkedList:

En el ejemplo dado, hemos usado el método get(i) . Aquí, el método devuelve el elemento que está en el i ^-ésimo índice.

Sintaxis:

LinkedList.get(int index)

Parámetros: el índice del parámetro es un tipo de datos entero que especifica la posición o el índice del elemento que se va a obtener de LinkedList.

Valor devuelto: el método devuelve el elemento presente en la posición especificada por el índice del parámetro .

// Java program to get the elements of Linkedlist
  
import java.io.*;
import java.util.LinkedList;
class GFG {
    public static void main(String[] args)
    {
  
        // Creating LinkedList
        LinkedList<String> gfg = new LinkedList<String>();
  
        // Adding values
        gfg.add("GEEKS");
        gfg.add("FOR");
        gfg.add("GEEKS");
  
        System.out.println("LinkedList Elements : ");
  
        for (int i = 0; i < gfg.size(); i++) {
  
            // get(i) returns element present at index i
            System.out.println("Element at index " + i
                               + " is: " + gfg.get(i));
        }
    }
}

LinkedList Elements : 
Element at index 0 is: GEEKS
Element at index 1 is: FOR
Element at index 2 is: GEEKS

2. Podemos usar el método iterator()

• Para usar este método, debemos importar el paquete java.util.Iterator .
• En este método, podemos iterar sobre LinkedList y luego extraer el elemento en el índice dado en consecuencia.

// Java program to iterate over linkedlist
// to extract elements of linkedlist
  
import java.io.*;
import java.util.LinkedList;
import java.util.Iterator;
class GFG {
    public static void main(String[] args)
    {
  
        LinkedList<String> gfg = new LinkedList<String>();
  
        // Adding elements
        gfg.add("GEEKS");
        gfg.add("FOR");
        gfg.add("GEEKS");
  
        // Create an object of Iterator
        Iterator<String> i = gfg.iterator();
  
        System.out.print(
            "The elements of the input LinkedList: \n");
  
        int j = 0;
  
        // has.next() returns true if there is a next
        // element
        while (i.hasNext()) {
  
            System.out.print("The element at the index " + j
                             + " ");
  
            // next() returns the next element
            String str = i.next();
  
            System.out.print(str);
            System.out.print(" \n");
  
            ++j;
        }
    }
}

The elements of the input LinkedList: 
The element at the index 0 GEEKS 
The element at the index 1 FOR 
The element at the index 2 GEEKS

3. Podemos usar el método ListIterator() .

• ListIterator() es una subinterfaz del método Iterator().
• Nos proporciona la función de acceder a los elementos de una lista.
• Es bidireccional, lo que significa que nos permite iterar elementos de una lista en ambas direcciones.
• Para usar este método, debemos importar java.util.ListIterator.

// Java program to iterate over the
// linkedlist using listIterator()
  
import java.io.*;
import java.util.LinkedList;
import java.util.ListIterator;
  
class GFG {
    public static void main(String[] args)
    {
  
        LinkedList<String> gfg = new LinkedList<String>();
  
        // Adding elements
        gfg.add("GEEKS");
        gfg.add("FOR");
        gfg.add("GEEKS");
  
        // Create an object of ListIterator
        ListIterator<String> li = gfg.listIterator();
  
        System.out.print(
            "The elements of the LinkedList: \n");
  
        // hasNext() returns true if there is next element
        int j = 0;
  
        while (li.hasNext()) {
  
            // next() returns the next element
            System.out.print("The element at the index " + j
                             + " ");
  
            System.out.print(li.next());
  
            System.out.print("\n");
  
            ++j;
        }
        --j;
  
        // Now to show that ListIterator() can traverse in
        // both the direction
        System.out.print(
            "\nThe elements of the LinkedList in Reverse order: \n");
  
        // hasprevious() checks if there is a previous
        // element
        while (li.hasPrevious()) {
  
            System.out.print("The element at the index " + j
                             + " ");
  
            // previous() returns the previous element
            System.out.print(li.previous());
            System.out.print("\n");
  
            --j;
        }
    }
}

The elements of the LinkedList: 
The element at the index 0 GEEKS
The element at the index 1 FOR
The element at the index 2 GEEKS

The elements of the LinkedList in Reverse order: 
The element at the index 2 GEEKS
The element at the index 1 FOR
The element at the index 0 GEEKS