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 .
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:
-
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]
-
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
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]
- Crear lista inmutable
-
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:
-
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]
-
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
-
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]
-
-
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]
-
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]