Cómo hacer una nueva lista en Java

762

Creamos un Setcomo:

Set myset = new HashSet()

¿Cómo creamos un Listen Java?

usuario93796
fuente
1
En el javadoc para List. "Todas las clases de implementación conocidas: AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector"
KitsuneYMG
121
Esta pregunta es uno de los principales éxitos de Google para "Java
Create List
52
Es una buena pregunta con buenas respuestas. Uno de los objetivos de Stack Overflow es crear algún tipo de respuesta canónica para preguntas de programación, al menos según los fundadores del sitio. Por lo tanto, intente evitar la baja de votos de este tipo de publicaciones en el futuro, si puede resistir la tentación.
eggonlegs

Respuestas:

977
List myList = new ArrayList();

o con genéricos ( Java 7 o posterior)

List<MyType> myList = new ArrayList<>();

o con genéricos (versiones antiguas de Java)

List<MyType> myList = new ArrayList<MyType>();
Dan Vinton
fuente
68
Tenga en cuenta que ArrayList no es el único tipo de Lista, y, con respecto a la pregunta, HashSet no es el único tipo de Conjunto.
delgado
17
Me sorprende que nadie haya mencionado que puede buscar la interfaz de la lista en la documentación de Java para obtener una lista definitiva de todas las clases que implementan Lista: docs.oracle.com/javase/7/docs/api/java/util /List.html
David Mason
55
Si usa un IDE, generalmente también puede ver una jerarquía de tipos allí, lo que puede ser más conveniente. En Eclipse, el acceso directo predeterminado es F4, y en IDEA es Ctrl + H.
David Mason
1
Por lo que entiendo, no puedes usar genéricos con ArrayList en C # MSDN
JohnOsborne
55
El segundo argumento de tipo explícito <MyType> se puede reemplazar con solo <> para Java 7 y 8.
Jannik
469

Además, si desea crear una lista que contenga elementos (aunque será de tamaño fijo):

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");
Aaron Maenpaa
fuente
15
La advertencia es que este tipo de lista (la que devuelve asList ()) es inmutable.
Avrom
70
@Avron - mal: se fija tamaño solamente: no se puede cambiar el tamaño, pero puede cambiar el contenido (salvedad de la advertencia?)
user85421
Increíble. Gracias por ser conciso.
R Claven
1
si solo hay una cosa en la lista, uso Collections.singletonList () en lugar de Arrays.asList (). (Pero, supongo, no sé por qué.)
MikeB
@MikeB si no sabes por qué, entonces quédate con los arrays.aslist
bharal
183

Déjame resumir y agregar algo:

JDK

1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

Guayaba

1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

Lista inmutable

1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));
2. ImmutableList.builder()                                      // Guava
            .add("A")
            .add("B").build();
3. ImmutableList.of("A", "B");                                  // Guava
4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava

Lista inmutable vacía

1. Collections.emptyList();
2. Collections.EMPTY_LIST;

Lista de personajes

1. Lists.charactersOf("String")                                 // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava

Lista de enteros

Ints.asList(1,2,3);                                             // Guava
Sergii Shevchyk
fuente
Ints.asListno crea una lista inmutable, sino una lista de tamaño fijo respaldada por una matriz dada de entradas (es decir, es compatible List.set(int, Object)). El segundo ejemplo de "Lista de caracteres inmutables" tampoco es inmutable (eliminaría esa línea).
Xaerxess el
99
No usar genéricos es un ejemplo realmente "bueno" para cualquier desarrollador que lea esto.
Natix
60

En Java 8

Para crear una lista no vacía de tamaño fijo (no se admiten operaciones como agregar, eliminar, etc.):

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

Para crear una lista mutable no vacía:

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

En Java 9

Usando nuevos List.of(...)métodos estáticos de fábrica:

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

List<Integer> mutableList = new ArrayList<>(List.of(3, 4));

En Java 10

Uso de la inferencia de tipo de variable local :

var list1 = List.of(1, 2);

var list2 = new ArrayList<>(List.of(3, 4));

var list3 = new ArrayList<String>();

Y siga las mejores prácticas ...

No uses tipos crudos

Desde Java 5, los genéricos han sido parte del lenguaje; debe usarlos:

List<String> list = new ArrayList<>(); // Good, List of String

List list = new ArrayList(); // Bad, don't do that!

Programa para interfaces

Por ejemplo, programe en la Listinterfaz:

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

En vez de:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!
Oleksandr Pyrohov
fuente
1
Hola, ¿podría sugerirme dónde puedo aprender estas diferencias y la evolución de Java? ¡Parece muy interesante!
shiv
31

Primero lea esto , luego lea esto y esto . 9 de cada 10 veces usará una de esas dos implementaciones.

De hecho, solo lea la Guía de Sun para el marco de Colecciones .

Adam Jaskiewicz
fuente
11
Incluso agregaría "8 de cada 10" que usará ArrayList, simplemente porque simplemente no importa en 9.9 de cada 10.
Joachim Sauer
1
LinkedList es semánticamente apropiado cuando realmente solo te importan los extremos.
Adam Jaskiewicz
Las LinkedLists son excelentes si solo va a iterar sobre ellas. Para mí, parece que las listas vinculadas son más elegantes, pero tal vez es solo porque aprendí lisp antes de Java.
KarlP
@Karlp De acuerdo. Yo diría que es aproximadamente 50/50 la mayor parte del tiempo entre ArrayList y LinkedList, y la respuesta no siempre es sobre la complejidad de las operaciones; más a menudo es simplemente lo que se siente bien para el problema en cuestión.
Adam Jaskiewicz
1
Casi siempre lo usaba ArrayList. Si solo estoy trabajando con los extremos de una lista, es una deque (o cola) y uso la ArrayDequeimplementación. La razón es que, aunque las implementaciones basadas en matrices pueden desperdiciar algo de memoria en ranuras vacías (cuando no puedo predecir la capacidad necesaria), para pequeñas colecciones esto es comparable a la sobrecarga de todas las instancias de nodo en una lista vinculada ( o deque). Y a cambio, obtengo acceso aleatorio. ¿Qué beneficio único LinkedListproporciona?
erickson
21
//simple example creating a list form a string array

String[] myStrings = new String[] {"Elem1","Elem2","Elem3","Elem4","Elem5"};

List mylist = Arrays.asList(myStrings );

//getting an iterator object to browse list items

Iterator itr= mylist.iterator();

System.out.println("Displaying List Elements,");

while(itr.hasNext())

  System.out.println(itr.next());
Blerta
fuente
21

Desde Java 7, tiene inferencia de tipos para la creación de instancias genéricas , por lo que no es necesario duplicar parámetros genéricos en el lado derecho de la asignación:

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

Una lista de tamaño fijo se puede definir como:

List<String> list = Arrays.asList("foo", "bar");

Para listas inmutables, puede usar la biblioteca Guava :

List<String> list = ImmutableList.of("foo", "bar");
Vitalii Fedorenko
fuente
Tengo una pregunta sobre esta declaración List <String> list = Arrays.asList ("foo", "bar"); Me pregunto si la lista en la declaración es un objeto.
20

List es solo una interfaz como Set .

Al igual que HashSet es una implementación de un conjunto que tiene ciertas propiedades con respecto a agregar / buscar / eliminar el rendimiento, ArrayList es la implementación básica de una lista.

Si echa un vistazo a la documentación de las interfaces respectivas, encontrará "Todas las clases de implementación conocidas" y podrá decidir cuál es la más adecuada para sus necesidades.

Lo más probable es que sea ArrayList .

Sorin Mocanu
fuente
18

Listes una interfaz como Sety tiene ArrayListy LinkedListcomo implementaciones de propósito general .

Podemos crear Lista como:

 List<String> arrayList = new ArrayList<>();
 List<String> linkedList = new LinkedList<>(); 

También podemos crear una lista de tamaño fijo como:

List<String> list = Arrays.asList("A", "B", "C");

Casi siempre estaríamos usando ArrayListopuestos a la LinkedListimplementación:

  1. LinkedList usa mucho espacio para objetos y funciona mal cuando tenemos muchos elementos.
  2. Cualquier operación indexada en LinkedListrequiere tiempo O (n) en comparación con O (1) en ArrayList.
  3. Consulte este enlace para más información.

La lista creada Arrays.asListanteriormente no puede modificarse estructuralmente, pero sus elementos aún pueden modificarse.

Java 8

Según el documento , el método Collections.unmodifiableListdevuelve una vista no modificable de la lista especificada. Podemos obtenerlo como:

Collections.unmodifiableList(Arrays.asList("A", "B", "C"));

Java 9

En caso de que estemos usando Java 9, entonces:

List<String> list = List.of("A", "B");

Java 10

En caso de que estemos en Java 10, el método Collectors.unmodifiableListdevolverá una instancia de lista verdaderamente inmodificable introducida en Java 9. Verifique esta respuesta para obtener más información sobre la diferencia entre Collections.unmodifiableList vs Collectors.unmodifiableListen Java 10 .

akhil_mittal
fuente
9

A veces, pero muy raramente, en lugar de una nueva ArrayList, es posible que desee una nueva LinkedList. Comience con ArrayList y si tiene problemas de rendimiento y evidencia de que la lista es el problema, y ​​si agrega y elimina mucho a esa lista, luego, no antes, cambie a LinkedList y vea si las cosas mejoran. Pero en general, quédate con ArrayList y todo estará bien.

Carl Manaster
fuente
9
List list = new ArrayList();

O con genéricos

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

Por supuesto, puede reemplazar la cadena con cualquier tipo de variable, como Integer, también.

Paulo Guedes
fuente
7

Un ejemplo:

List somelist = new ArrayList();

Puede consultar la lista de javadoc y encontrar todas las clases de implementación conocidas de la Listinterfaz que se incluyen con la API de Java.

Alex B
fuente
7

Con Google Collections , puede usar los siguientes métodos en la clase Listas

import com.google.common.collect.Lists;

// ...

List<String> strings = Lists.newArrayList();

List<Integer> integers = Lists.newLinkedList();

Hay sobrecargas para la inicialización de varargs y la inicialización de un Iterable<T>.

La ventaja de estos métodos es que no necesita especificar el parámetro genérico explícitamente como lo haría con el constructor; el compilador lo inferirá del tipo de la variable.

Ben Lings
fuente
6
List<Object> nameOfList = new ArrayList<Object>();

Necesitas importar Listy ArrayList.

jp093121
fuente
6

Más opciones para hacer lo mismo con Java 8, no mejor, no peor, solo diferente y si desea hacer un trabajo adicional con las listas, Streams le proporcionará más alternativas (filtro, mapa, reducción, etc.)

List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());
List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());
List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());
LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));
whyem
fuente
6

Con Java 9, puede hacer lo siguiente para crear un elemento inmutable List :

List<Integer> immutableList = List.of(1, 2, 3, 4, 5);

List<Integer> mutableList = new ArrayList<>(immutableList);
Jacob G.
fuente
6

Como opción, puede usar la inicialización de doble llave aquí:

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};
angry_gopher
fuente
2
Esta es una operación costosa. Está creando una subclase anónima de ArrayList aquí.
Vikram Bodicherla
@VikramBodicherla Estoy de acuerdo. Aquí se trata más del azúcar de sintaxis.
angry_gopher
5
List arrList = new ArrayList();

Es mejor que use genéricos como se sugiere a continuación:

List<String> arrList = new ArrayList<String>();

arrList.add("one");

En caso de que use LinkedList.

List<String> lnkList = new LinkedList<String>();
Rohit Goyal
fuente
4

Con Eclipse Collections puedes crear una lista como esta:

List<String> list1 = Lists.mutable.empty();
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

Si quieres una lista inmutable:

ImmutableList<String> list3 = Lists.immutable.empty();
ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");

Puede evitar el auto-boxeo utilizando listas primitivas. Así es como crearías listas int:

MutableIntList list5 = IntLists.mutable.empty();
MutableIntList list6 = IntLists.mutable.of(1, 2, 3);

ImmutableIntList list7 = IntLists.immutable.empty();
ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);

Hay variantes para las 8 primitivas.

MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);
MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);
MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);
MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);

Nota: Soy un committer para Eclipse Collections.

Craig P. Motlin
fuente
4

Las siguientes son algunas formas en que puede crear listas.

  • Esto creará una lista con un tamaño fijo, no es posible agregar / eliminar elementos, arrojará un java.lang.UnsupportedOperationExceptionsi intenta hacerlo.

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});


  • La siguiente versión es una lista simple donde puede agregar / eliminar cualquier número de elementos.

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


  • Esta es la forma de crear un LinkedListarchivo in java. Si necesita hacer una inserción / eliminación frecuente de elementos en la lista, debe usar en LinkedListlugar deArrayList

    List<String> linkedList = new LinkedList<>();
JoBⅈN
fuente
1
Puedes usar Arrays.asList("Male", "Female").
Johny
3

Prueba esto:

List<String> messages = Arrays.asList("bla1", "bla2", "bla3");

O:

List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");
Gavriel Cohen
fuente
2

Si necesita una lista inmutable serializable con una sola entidad que puede usar:

List<String> singList = Collections.singletonList("stackoverlow");
erol yeniaras
fuente
2

Como la declaración de la lista de matriz en java es como

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable  

Hay muchas formas de crear e inicializar la lista de matrices en Java.

 1) List list = new ArrayList();

 2) List<type> myList = new ArrayList<>();

 3) List<type> myList = new ArrayList<type>();

 4) Using Utility class

    List<Integer> list = Arrays.asList(8, 4);
    Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

 5) Using static factory method

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


 6) Creation and initializing at a time

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});



 Again you can create different types of list. All has their own characteristics

 List a = new ArrayList();
 List b = new LinkedList();
 List c = new Vector(); 
 List d = new Stack(); 
 List e = new CopyOnWriteArrayList();
Mak
fuente