Interfaz de lista en Java con ejemplos

La interfaz List en Java proporciona una forma de almacenar la colección ordenada. Es una interfaz secundaria de Collection . Es una colección ordenada de objetos en los que se pueden almacenar valores duplicados. Dado que List conserva el orden de inserción, permite el acceso posicional y la inserción de elementos. 

La interfaz List se encuentra en el paquete java.util y hereda la interfaz Collection. Es una fábrica de interfaz ListIterator. A través de ListIterator, podemos iterar la lista hacia adelante y hacia atrás. Las clases de implementación de la interfaz List son ArrayList, LinkedList, Stack y Vector. ArrayList y LinkedList se utilizan ampliamente en la programación de Java. La clase Vector está en desuso desde Java 5.

Declaración: La interfaz de lista se declara como:

public interface List<E> extends Collection<E> ; 

Profundicemos en la creación de objetos o instancias en una clase List. Dado que List es una interfaz , no se pueden crear objetos del tipo list. Siempre necesitamos una clase que implemente esta Lista para crear un objeto. Y también, después de la introducción de Generics en Java 1.5, es posible restringir el tipo de objeto que se puede almacenar en la Lista. Al igual que otras ‘interfaces’ definidas por el usuario implementadas por ‘clases’ definidas por el usuario, List es una ‘interfaz’, implementada por la clase ArrayList , predefinida en el paquete  java.util .

Sintaxis: este tipo de lista segura se puede definir como:

List<Obj> list = new ArrayList<Obj> (); 

Nota: Obj es el tipo de objeto que se almacenará en Lista

Ejemplo:

// Java program to Demonstrate List Interface
  
// Importing all utility classes
import java.util.*;
  
// Main class
// ListDemo class
class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Creating an object of List interface
         // implemented by the ArrayList class
        List<Integer> l1 = new ArrayList<Integer>();
  
        // Adding elements to object of List interface
        // Custom inputs
  
        l1.add(0, 1);
        l1.add(1, 2);
  
        // Print the elements inside the object
        System.out.println(l1);
  
        // Now creating another object of the List 
        // interface implemented ArrayList class
        // Declaring object of integer type
        List<Integer> l2 = new ArrayList<Integer>();
  
        // Again adding elements to object of List interface
        // Custom inputs
        l2.add(1);
        l2.add(2);
        l2.add(3);
  
        // Will add list l2 from 1 index
        l1.addAll(1, l2);
  
        System.out.println(l1);
  
        // Removes element from index 1
        l1.remove(1);
  
        // Printing the updated List 1
        System.out.println(l1);
  
        // Prints element at index 3 in list 1
        // using get() method
        System.out.println(l1.get(3));
  
        // Replace 0th element with 5
        // in List 1
        l1.set(0, 5);
  
        // Again printing the updated List 1
        System.out.println(l1);
    }
}

[1, 2]
[1, 1, 2, 3, 2]
[1, 2, 3, 2]
2
[5, 2, 3, 2]

Ahora permítanos realizar varias operaciones usando la interfaz de lista para tener una mejor comprensión de la misma. Discutiremos las siguientes operaciones que se enumeran a continuación y más adelante las implementaremos a través de códigos java limpios.

Operaciones en una interfaz de lista

Dado que List es una interfaz, solo se puede usar con una clase que implemente esta interfaz. Ahora, veamos cómo realizar algunas operaciones de uso frecuente en la Lista.  

• Operación 1: agregar elementos a la clase List usando el método add()
• Operación 2: Actualización de elementos en la clase Lista usando el método set()
• Operación 3: Eliminar elementos usando el método remove()

Ahora analicemos las operaciones individualmente e implementemos lo mismo en el código para comprenderlo mejor.

Operación 1:  agregar elementos a la clase List usando el método add()

Para agregar un elemento a la lista, podemos usar el método add() . Este método está sobrecargado para realizar múltiples operaciones basadas en diferentes parámetros.

Parámetros:  Toma 2 parámetros, a saber: 

• add(Object): Este método se utiliza para agregar un elemento al final de la Lista.
• add(int index, Object): Este método se usa para agregar un elemento en un índice específico en la Lista

Ejemplo: 

// Java Program to Add Elements to a List
  
// Importing all utility classes
import java.util.*;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String args[])
    {
        // Creating an object of List interface, 
        // implemented by ArrayList class
        List<String> al = new ArrayList<>();
  
        // Adding elements to object of List interface
        // Custom elements
        al.add("Geeks");
        al.add("Geeks");
        al.add(1, "For");
  
        // Print all the elements inside the
        // List interface object
        System.out.println(al);
    }
}

[Geeks, For, Geeks]

Operación 2: Actualización de elementos

Después de agregar los elementos, si deseamos cambiar el elemento, se puede hacer usando el método set() . Dado que List está indexado, el elemento que deseamos cambiar está referenciado por el índice del elemento. Por lo tanto, este método toma un índice y el elemento actualizado que debe insertarse en ese índice. 

Ejemplo: 

// Java Program to Update Elements in a List
  
// Importing utility classes
import java.util.*;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String args[])
    {
        // Creating an object of List interface
        List<String> al = new ArrayList<>();
  
        // Adding elements to object of List class
        al.add("Geeks");
        al.add("Geeks");
        al.add(1, "Geeks");
  
        // Display theinitial elements in List
        System.out.println("Initial ArrayList " + al);
  
        // Setting (updating) element at 1st index
        // using set() method
        al.set(1, "For");
  
        // Print and display the updated List
        System.out.println("Updated ArrayList " + al);
    }
}

Initial ArrayList [Geeks, Geeks, Geeks]
Updated ArrayList [Geeks, For, Geeks]

Operación 3: Eliminación de elementos

Para eliminar un elemento de una lista, podemos usar el método remove() . Este método está sobrecargado para realizar múltiples operaciones basadas en diferentes parámetros. Están:

Parámetros:  

• remove(Object): este método se usa simplemente para eliminar un objeto de la Lista. Si hay varios de estos objetos, se elimina la primera aparición del objeto.
• remove(int index): dado que una Lista está indexada, este método toma un valor entero que simplemente elimina el elemento presente en ese índice específico en la Lista. Después de eliminar el elemento, todos los elementos se mueven hacia la izquierda para llenar el espacio y se actualizan los índices de los objetos.

Ejemplo: 

// Java Program to Remove Elements from a List
  
// Importing List and ArrayList classes
// from java.util package
import java.util.ArrayList;
import java.util.List;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String args[])
    {
  
        // Creating List class object
        List<String> al = new ArrayList<>();
  
        // Adding elements to the object
        // Custom inputs
        al.add("Geeks");
        al.add("Geeks");
  
        // Adding For at 1st indexes
        al.add(1, "For");
  
        // Print the initialArrayList
        System.out.println("Initial ArrayList " + al);
  
        // Now remove element from the above list
        // present at 1st index
        al.remove(1);
  
        // Print the List after removal of element
        System.out.println("After the Index Removal " + al);
  
        // Now remove the current object from the updated
        // List
        al.remove("Geeks");
  
        // Finally print the updated List now
        System.out.println("After the Object Removal "
                           + al);
    }
}

Initial ArrayList [Geeks, For, Geeks]
After the Index Removal [Geeks, Geeks]
After the Object Removal [Geeks]

Iterando sobre Lista 

Hasta ahora tenemos un tamaño de entrada muy pequeño y estamos haciendo operaciones manualmente para cada entidad. Ahora analicemos varias formas en las que podemos iterar sobre la lista para que funcionen para un conjunto de muestra más grande.  

Métodos: Hay varias formas de iterar a través de la Lista. Las formas más famosas son usar el bucle for básico en combinación con un método get() para obtener el elemento en un índice específico y el bucle for avanzado . 

Ejemplo: 

// Java program to Iterate the Elements
// in an ArrayList
  
// Importing java utility classes
import java.util.*;
  
// Main class
public class GFG {
  
    // main driver method
    public static void main(String args[])
    {
        // Creating an empty Arraylist of string type
        List<String> al = new ArrayList<>();
  
        // Adding elements to above object of ArrayList
        al.add("Geeks");
        al.add("Geeks");
  
        // Adding element at specified position
        // inside list object
        al.add(1, "For");
  
        // Using  for loop for iteration
        for (int i = 0; i < al.size(); i++) {
  
            // Using get() method to
            // access particular element
            System.out.print(al.get(i) + " ");
        }
  
        // New line for better readability
        System.out.println();
  
        // Using for-each loop for iteration
        for (String str : al)
  
            // Printing all the elements
            // which was inside object
            System.out.print(str + " ");
    }
}

Geeks For Geeks 
Geeks For Geeks 

Métodos de la interfaz de lista

Dado que el concepto principal detrás de los diferentes tipos de listas es el mismo, la interfaz de listas contiene los siguientes métodos:

Lista Java vs Conjunto

Tanto la interfaz List como la interfaz Set heredan la interfaz Collection. Sin embargo, existen algunas diferencias entre ellos.

Asociación de clases con una interfaz de lista

Ahora analicemos las clases que implementan la interfaz de lista para lo cual primero consulte la representación pictórica a continuación para tener una mejor comprensión de la interfaz de lista. Es como sigue: 

AbstractList , CopyOnWriteArrayList y AbstractSequentialList son las clases que implementan la interfaz List. Se implementa una funcionalidad separada en cada una de las clases mencionadas. Son los siguientes:

1. AbstractList: esta clase se usa para implementar una lista no modificable, para lo cual solo se necesita extender esta clase AbstractList e implementar solo los métodos get() y size() .
2. CopyOnWriteArrayList: esta clase implementa la interfaz de lista. Es una versión mejorada de ArrayList en la que todas las modificaciones (agregar, establecer, eliminar, etc.) se implementan al hacer una copia nueva de la lista.
3. AbstractSequentialList: esta clase implementa la interfaz Collection y la clase AbstractCollection. Esta clase se usa para implementar una lista no modificable, para lo cual solo se necesita extender esta clase AbstractList e implementar solo los métodos get() y size() .

Procederemos de esta manera. 

• Lista de arreglo
• Vector
• Pila
• Lista enlazada

Discutámoslos secuencialmente e implementémoslos para descubrir el funcionamiento de las clases con la interfaz List. 

Clase 1: ArrayList

Una clase ArrayList que se implementa en el marco de la colección nos proporciona arrays dinámicas en Java. Sin embargo, puede ser más lento que las arrays estándar, pero puede ser útil en programas donde se necesita mucha manipulación en la array. Veamos cómo crear un objeto de lista usando esta clase. 

Ejemplo:

// Java program to demonstrate the
// creation of list object using the
// ArrayList class
  
import java.io.*;
import java.util.*;
  
class GFG {
    public static void main(String[] args)
    {
        // Size of ArrayList
        int n = 5;
  
        // Declaring the List with initial size n
        List<Integer> arrli
            = new ArrayList<Integer>(n);
  
        // Appending the new elements
        // at the end of the list
        for (int i = 1; i <= n; i++)
            arrli.add(i);
  
        // Printing elements
        System.out.println(arrli);
  
        // Remove element at index 3
        arrli.remove(3);
  
        // Displaying the list after deletion
        System.out.println(arrli);
  
        // Printing elements one by one
        for (int i = 0; i < arrli.size(); i++)
            System.out.print(arrli.get(i) + " ");
    }
}

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5 

Clase 2: Vectorial

Vector es una clase que se implementa en el marco de la colección e implementa una array creciente de objetos. Vector implementa una array dinámica que significa que puede crecer o reducirse según sea necesario. Al igual que una array, contiene componentes a los que se puede acceder mediante un índice entero. Los vectores básicamente pertenecen a las clases heredadas, pero ahora son totalmente compatibles con las colecciones. Veamos cómo crear un objeto de lista usando esta clase. 

Ejemplo:

// Java program to demonstrate the
// creation of list object using the
// Vector class
  
import java.io.*;
import java.util.*;
  
class GFG {
    public static void main(String[] args)
    {
        // Size of the vector
        int n = 5;
  
        // Declaring the List with initial size n
        List<Integer> v = new Vector<Integer>(n);
  
        // Appending the new elements
        // at the end of the list
        for (int i = 1; i <= n; i++)
            v.add(i);
  
        // Printing elements
        System.out.println(v);
  
        // Remove element at index 3
        v.remove(3);
  
        // Displaying the list after deletion
        System.out.println(v);
  
        // Printing elements one by one
        for (int i = 0; i < v.size(); i++)
            System.out.print(v.get(i) + " ");
    }
}

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5 

Clase 3: Pila

Stack es una clase que se implementa en el marco de la colección y amplía los modelos de clases vectoriales e implementa la estructura de datos Stack . La clase se basa en el principio básico de último en entrar, primero en salir. Además de las operaciones básicas de inserción y extracción, la clase proporciona tres funciones más de vaciar, buscar y mirar. Veamos cómo crear un objeto de lista usando esta clase.

Ejemplo:

// Java program to demonstrate the
// creation of list object using the
// Stack class
  
import java.io.*;
import java.util.*;
  
class GFG {
    public static void main(String[] args)
    {
        // Size of the stack
        int n = 5;
  
        // Declaring the List
        List<Integer> s = new Stack<Integer>();
  
        // Appending the new elements
        // at the end of the list
        for (int i = 1; i <= n; i++)
            s.add(i);
  
        // Printing elements
        System.out.println(s);
  
        // Remove element at index 3
        s.remove(3);
  
        // Displaying the list after deletion
        System.out.println(s);
  
        // Printing elements one by one
        for (int i = 0; i < s.size(); i++)
            System.out.print(s.get(i) + " ");
    }
}

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5 

Clase 4: Lista Vinculada

LinkedList es una clase que se implementa en el marco de la colección que implementa inherentemente la estructura de datos de la lista vinculada . Es una estructura de datos lineal donde los elementos no se almacenan en ubicaciones contiguas y cada elemento es un objeto separado con una parte de datos y una parte de dirección. Los elementos se vinculan mediante punteros y direcciones. Cada elemento se conoce como un Node. Debido a la dinámica y la facilidad de las inserciones y eliminaciones, son preferibles a las arrays. Veamos cómo crear un objeto de lista usando esta clase.

Ejemplo:

// Java program to demonstrate the
// creation of list object using the
// LinkedList class
  
import java.io.*;
import java.util.*;
  
class GFG {
    public static void main(String[] args)
    {
        // Size of the LinkedList
        int n = 5;
  
        // Declaring the List with initial size n
        List<Integer> ll = new LinkedList<Integer>();
  
        // Appending the new elements
        // at the end of the list
        for (int i = 1; i <= n; i++)
            ll.add(i);
  
        // Printing elements
        System.out.println(ll);
  
        // Remove element at index 3
        ll.remove(3);
  
        // Displaying the list after deletion
        System.out.println(ll);
  
        // Printing elements one by one
        for (int i = 0; i < ll.size(); i++)
            System.out.print(ll.get(i) + " ");
    }
}

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5