Inicializar una lista en Java

Posted on by Rudeus Greyrat

Java.util.List 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 de lista se implementa mediante las clases ArrayList , LinkedList , Vector y Stack .

listinterfacejava

List es una interfaz, y las instancias de List se pueden crear de las siguientes maneras:

List a = new ArrayList();
List b = new LinkedList();
List c = new Vector(); 
List d = new Stack();

>

A continuación se muestran las siguientes formas de inicializar una lista:

  1. Usando el método List.add()

    Dado que la lista es una interfaz, no se puede crear una instancia directamente. Sin embargo, uno puede crear objetos de aquellas clases que han implementado esta interfaz e instanciarlos.

    Algunas clases que han implementado la interfaz List son Stack, ArrayList, LinkedList, Vector, etc.

    Sintaxis:

    List<Integer> list=new ArrayList<Integer>();
List<Integer> llist=new LinkedList<Integer>();
List<Integer> stack=new Stack<Integer>();

    Ejemplos:

    import java.util.*;
    import java.util.function.Supplier;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // For ArrayList
            List<Integer> list = new ArrayList<Integer>();
            list.add(1);
            list.add(3);
            System.out.println("ArrayList : " + list.toString());
      
            // For LinkedList
            List<Integer> llist = new LinkedList<Integer>();
            llist.add(2);
            llist.add(4);
            System.out.println("LinkedList : " + llist.toString());
      
            // For Stack
            List<Integer> stack = new Stack<Integer>();
            stack.add(3);
            stack.add(1);
            System.out.println("Stack : " + stack.toString());
        }
    }
    Producción:

    ArrayList : [1, 3]
LinkedList : [2, 4]
Stack : [3, 1]

    La inicialización de doble llave también se puede utilizar para realizar el trabajo anterior.

    Sintaxis:

    List<Integer> list=new ArrayList<Integer>(){{
                        add(1);
                        add(2);
                        add(3);
                          }};

    Ejemplos:

    import java.util.*;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // For ArrayList
            List<Integer> list = new ArrayList<Integer>() {{
                add(1);
                add(3);
                } };
            System.out.println("ArrayList : " + list.toString());
      
            // For LinkedList
            List<Integer> llist = new LinkedList<Integer>() {{
                add(2);
                add(4);
                } };
            System.out.println("LinkedList : " + llist.toString());
      
            // For Stack
            List<Integer> stack = new Stack<Integer>() {{
                add(3);
                add(1);
                } };
            System.out.println("Stack : " + stack.toString());
        }
    }
    Producción:

    ArrayList : [1, 3]
LinkedList : [2, 4]
Stack : [3, 1]

  2. Usando arrays.asList()

    • Crear lista inmutable

      Arrays.asList() crea una lista inmutable a partir de una array. Por lo tanto, se puede usar para instanciar una lista con una array.

      Sintaxis:

      List<Integer> list=Arrays.asList(1, 2, 3);

      Ejemplos:

      import java.util.Arrays;
      import java.util.List;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Instantiating List using Arrays.asList()
              List<Integer> list = Arrays.asList(1, 2, 3);
        
              // Print the list
              System.out.println("List : " + list.toString());
          }
      }
      Producción:

      List : [1, 2, 3]
    • Creación de una lista mutable

      Curso básico de Java

      Sintaxis:

      List<Integer> list=new ArrayList<>(Arrays.asList(1, 2, 3));

      Ejemplos:

      import java.util.ArrayList;
      import java.util.Arrays;
      import java.util.List;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Creating a mutable list using Arrays.asList()
              List<Integer> list = new ArrayList<>(
                  Arrays.asList(1, 2, 3));
        
              // Print the list
              System.out.println("List : " + list.toString());
        
              list.add(5);
        
              // Print the list
              System.out.println("Modified list : " + list.toString());
          }
      }
      Producción:

      List : [1, 2, 3]
Modified list : [1, 2, 3, 5]

  3. Usando los métodos de la clase Collections

    Hay varios métodos en la clase Collections que se pueden usar para instanciar una lista. Están:

    1. Usando Colecciones.addAll()

      La clase Collections tiene un método estático addAll() que se puede usar para inicializar una lista. Collections.addAll() toma cualquier número de elementos después de que se especifica con la colección en la que se van a insertar los elementos.

      Sintaxis:

      List<Integer> list = Collections.EMPTY_LIST;
Collections.addAll(list = new ArrayList<Integer>(), 1, 2, 3, 4);

      Ejemplos:

      import java.util.*;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Create an empty list
              List<Integer> list = new ArrayList<Integer>();
        
              // Instantiating list using Collections.addAll()
              Collections.addAll(list, 1, 2, 3, 4);
        
              // Print the list
              System.out.println("List : " + list.toString());
          }
      }
      Producción:

      List : [1, 2, 3, 4]

    2. Uso de Collections.unmodifiableList()

      Collections.unmodifiableList() devuelve una lista que no se puede modificar, es decir, no puede agregar ni eliminar un elemento. Cualquier intento de modificar la lista dará como resultado un UnsupportedOperationExample.

      Sintaxis:

      List<Integer> list = Collections
        .unmodifiableList(Arrays.asList(1, 2, 3));

      Ejemplo 1:

      import java.util.*;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Creating the list
              List<Integer> list = Collections.unmodifiableList(
                  Arrays.asList(1, 2, 3));
        
              // Print the list
              System.out.println("List : " + list.toString());
          }
      }
      Producción:

      List : [1, 2, 3]

      Ejemplo 2:

      import java.util.*;
        
      public class GFG {
          public static void main(String args[])
          {
        
              try {
                  // Creating the list
                  List<Integer> list = Collections.unmodifiableList(
                      Arrays.asList(1, 2, 3));
        
                  // Print the list
                  System.out.println("List : " + list.toString());
        
                  // Trying to modify the list
                  System.out.println("Trying to modify the list");
                  list.set(0, list.get(0));
              }
        
              catch (Exception e) {
                  System.out.println("Exception : " + e);
              }
          }
      }
      Producción:

      List : [1, 2, 3]
Trying to modify the list
Exception : java.lang.UnsupportedOperationException

    3. Usando Colecciones.singletonList()

      Collections.singletonList() devuelve una lista inmutable que consta de un solo elemento.

      Sintaxis:

      List<Integer> list = Collections.singletonList(2);

      Ejemplo 1:

      import java.util.*;
        
      public class GFG {
          public static void main(String args[])
          {
        
              // Creating the list
              List<Integer> list = Collections.singletonList(2);
        
              // Print the list
              System.out.println("List : " + list.toString());
          }
      }
      Producción:

      List : [2]

  4. Uso de flujo de Java 8

    Con la introducción de Stream y la programación funcional en Java 8, ahora se puede construir cualquier flujo de objetos y luego recopilarlos como una lista.

    Sintaxis:

    1.  List<Integer> list 
            = Stream.of(1, 2, 3)
                .collect(Collectors.toList());
2.  List<Integer> list 
            = Stream.of(1, 2, 3)
                .collect(Collectors.toCollection(ArrayList::new));
3.  List<Integer> list 
            = Stream.of(1, 2, 3, 4)
                .collect(Collectors.collectingAndThen(Collectors.toList(), 
                            Collections::unmodifiableList));

    Ejemplos:

    import java.util.*;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // Creating a List using Syntax 1
            List<Integer> list1 = Stream.of(1, 2, 3)
                                      .collect(Collectors.toList());
      
            // Printing the list
            System.out.println("List using Syntax 1: "
                               + list1.toString());
      
            // Creating a List using Syntax 2
            List<Integer> list2 = Stream
                                      .of(3, 2, 1)
                                      .collect(
                                          Collectors
                                              .toCollection(ArrayList::new));
      
            // Printing the list
            System.out.println("List using Syntax 2: "
                               + list2.toString());
      
            // Creating a List using Syntax 3
            List<Integer> list3 = Stream
                                      .of(1, 2, 3, 4)
                                      .collect(
                                          Collectors
                                              .collectingAndThen(
                                                  Collectors.toList(),
                                                  Collections::unmodifiableList));
      
            // Printing the list
            System.out.println("List using Syntax 3: "
                               + list3.toString());
        }
    }
    Producción:

    List using Syntax 1: [1, 2, 3]
List using Syntax 2: [3, 2, 1]
List using Syntax 3: [1, 2, 3, 4]

  5. Usando Java 9 List.of()

    Java 9 introdujo el método List.of() que toma cualquier cantidad de argumentos y construye una lista compacta e inmodificable a partir de ellos.

    Sintaxis:

    List<Integer> unmodifiableList = List.of(1, 2, 3);

    Ejemplos:

    import java.util.List;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // Creating a list using List.of()
            List<Integer> unmodifiableList = List.of(1, 2, 3);
      
            // Printing the List
            System.out.println("List : "
                               + unmodifiableList.toString());
        }
    }

    PRODUCCIÓN:

    [1, 2, 3]

Publicación traducida automáticamente

Artículo escrito por psil123 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *