Inicialización de una ArrayList en una línea

Quería crear una lista de opciones con fines de prueba. Al principio, hice esto:

ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");

Luego, refactoricé el código de la siguiente manera:

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

¿Hay una mejor manera de hacer esto?

preguntado el 17 de junio de 09 a las 01:06

Si está destinado a pruebas unitarias, pruebe con groovy para un swing. Puede escribir su código de prueba en él mientras prueba el código java y usar ArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"] -

En Java SE 7, puede sustituir el tipo parametrizado del constructor con un conjunto vacío de parámetros de tipo (<>): Mapa > myMap = nuevo HashMap <> (); -

utilizar inicialización de doble refuerzo :) -

Stream.of ("val1", "val2"). Collect (Collectors.toList ()); // crea ArrayList, solución Java8. -

30 Respuestas

En realidad, probablemente la "mejor" forma de inicializar el ArrayList es el método que escribió, ya que no necesita crear un nuevo List de cualquier manera:

ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

El problema es que hay que escribir bastante para hacer referencia a eso list ejemplo.

Hay alternativas, como crear una clase interna anónima con un inicializador de instancia (también conocida como "inicialización de doble llave"):

ArrayList<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};

Sin embargo, no me gusta mucho ese método porque terminas con una subclase de ArrayList que tiene un inicializador de instancia, y esa clase se crea solo para crear un objeto, eso me parece un poco exagerado.

Lo que hubiera sido bueno fue si el Propuesta de Literales de Colección por Proyecto Moneda fue aceptado (estaba programado para ser introducido en Java 7, pero tampoco es probable que forme parte de Java 8):

List<String> list = ["A", "B", "C"];

Desafortunadamente, no le ayudará aquí, ya que inicializará un inmutable List en lugar de un ArrayListy, además, aún no está disponible, si es que alguna vez lo estará.

respondido 13 mar '15, 15:03

Ver stackoverflow.com/questions/924285 para obtener más información sobre la inicialización de doble refuerzo, los pros y los contras. - Eddie

@Eddie: Buena decisión para el enlace: una oración sobre la inicialización de doble llave no es suficiente para describirlo completamente. - Coobird

Solo funciona si no confías en la lista de boxeo automático lista = [1.0, 2.0, 3.0]; falla. - Richard B

@chelder, ¿podrías darnos más detalles? List<String> list = ["A", "B", "C"]; no funciona aquí. Gracias. - Galath

Dado que esta respuesta es la Project Coin más votada y mencionada, creo que debería mencionar que java 9 se envió con la sintaxis List. De (...): docs.oracle.com/javase/9/docs/api/java/util/List.html#of-E...- - Asaf

Sería más sencillo si lo declararas como un List - ¿Tiene que ser un ArrayList?

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

O si solo tiene un elemento:

List<String> places = Collections.singletonList("Buenos Aires");

Esto significaría que places is inmutable (intentar cambiarlo provocará un UnsupportedOperationException excepción a ser lanzada).

Para hacer una lista mutable que sea un concreto ArrayList puedes crear un ArrayList de la lista inmutable:

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Respondido el 16 de junio de 16 a las 22:06

@Marcase: ¿No puedes cambiar tu clase para usar una Lista en lugar de ArrayList? - lorenzo dol

Según mi respuesta, si no está utilizando métodos específicos para ArrayList, sería mejor cambiar la declaración a List. Especifique interfaces, no implementaciones. - Christoffer Hammarström

@Christoffer Hammarström: si cambia la declaración a Lista y usa el Lista lugares = Arrays.asList (...); él no podrá usar places.add ("blabla") - Maks

Solo para ser claro, asList(...) devuelve un tamaño fijo List que explota en operaciones mutantes como remove y clear, cosas de la List Contratar reclamaciones de apoyo. Incluso si dejaste la declaración como List, necesitas usar List l = new ArrayList(asList(...)) para obtener un objeto que no arroje excepciones OperationNotSupported. Principio de sustitución de Liskov ¿alguien? - chapoteo

@Chapoteo: remove y clear son operaciones opcionales en List, asi que asList(...) sigue el contrato. En ninguna parte el OP dice que necesita agregar más elementos más adelante, el ejemplo es solo de un List que debe inicializarse con tres elementos. - Christoffer Hammarström

La simple respuesta

In Java 9 o más tarde, después List.of() fue añadido:

List<String> strings = List.of("foo", "bar", "baz");

Con Java 10 o más tarde, esto se puede acortar con la var palabra clave.

var strings = List.of("foo", "bar", "baz");

Esto te dará una inmutable List, por lo que no se puede cambiar.
Que es lo que desea en la mayoría de los casos en los que lo está prepoblando.


Java 8 o anterior:

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

Esto te dará una List respaldado por una matriz, por lo que no puede cambiar la longitud.
Pero puedes llamar List.set, entonces todavía es mudable.


Usted puede hacer Arrays.asList aún más corto con una importación estática:

List<String> strings = asList("foo", "bar", "baz");

La importación estática:

import static java.util.Arrays.asList;  

Lo que cualquier IDE moderno sugerirá y hará automáticamente por usted.
Por ejemplo, en IntelliJ IDEA, presiona Alt+Enter y seleccionar Static import method....


Sin embargo, no recomiendo acortar el List.of método para of, porque eso se vuelve confuso.
List.of ya es lo suficientemente corto y se lee bien.


Usar Streams

¿Por qué tiene que ser un List?
Con Java 8 o posterior, puede utilizar un Stream que es más flexible:

Stream<String> strings = Stream.of("foo", "bar", "baz");

Puedes concatenar Streams:

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

O puedes ir de un Stream a una List:

import static java.util.stream.Collectors.toList;

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

Pero preferiblemente, solo use el Stream sin recogerlo en un List.


Si democracia específicamente necesita un java.util.ArrayList

(Probablemente no lo hagas).
Para citar JEP 269 (énfasis mío):

Hay un pequeño conjunto de casos de uso para inicializar una instancia de colección mutable con un conjunto predefinido de valores. Por lo general, es preferible tener esos valores predefinidos en una colección inmutable y luego inicializar la colección mutable a través de un constructor de copia.


Si deseas ambas prepoblar un ArrayList y agregarlo después (¿por qué?), usar

ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");

o en Java 8 o anterior:

ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");

o utilizando Stream:

import static java.util.stream.Collectors.toCollection;

ArrayList<String> strings = Stream.of("foo", "bar")
                             .collect(toCollection(ArrayList::new));
strings.add("baz");

Pero de nuevo, es mejor usar el Stream directamente en lugar de recogerlo en un List.


Programa a interfaces, no a implementaciones

Dijiste que declaraste la lista como ArrayList en su código, pero solo debe hacerlo si está utilizando algún miembro de ArrayList eso no está en List.

Lo que probablemente no esté haciendo.

Por lo general, debe declarar las variables mediante la interfaz más general que va a utilizar (p. Ej. Iterable, Collectiono List) e inicializarlos con la implementación específica (p. ej. ArrayList, LinkedList or Arrays.asList()).

De lo contrario, está limitando su código a ese tipo específico y será más difícil cambiarlo cuando lo desee.

Por ejemplo, si pasa un ArrayList a una void method(...):

// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) { 
    for (String s : strings) { ... } 
}

// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
    if (!strings.isEmpty()) { strings.stream()... }
}

// List if you also need .get(index):
void method(List<String> strings) {
    strings.get(...)
}

// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
    ??? // You don't want to limit yourself to just ArrayList
}

Otro ejemplo sería siempre declarar la variable an InputStream aunque suele ser un FileInputStream o con una BufferedInputStream, porque algún día, pronto, tú u otra persona querrán utilizar algún otro tipo de InputStream.

Respondido el 20 de junio de 20 a las 10:06

@bandera pirata: Arrays.asList es un método estático. Ver docs.oracle.com/javase/1.5.0/docs/guide/language/… - Christoffer Hammarström

@ ChristofferHammarström En ese caso, mi mente novato me dice que la importación estática tiene un gran parecido con las variables globales y los peligros que pertenecen a tal uso. ¿Es esta suposición correcta y es también la razón por la que la respuesta similar anterior obtuvo más votos? - bandera pirata

Creo que la respuesta anterior de la que estás hablando se hizo un año antes. Y no, el problema con las variables globales es que son mutables. No tienen nada que ver con las importaciones estáticas. - Christoffer Hammarström

Si no desea la importación estática, también puede definir la ruta completa al método asList estático, así: List cadenas = java.util.Arrays.asList ("", ""); - Geert Weening

O puede utilizar import java.util.Arrays; y Arrays.asList ("", ""); No es necesario que utilice una importación estática. No es necesario que utilice una ruta completa. Los métodos estáticos no se preocupan por la importación. Simplemente se molestan si usa una instancia para encontrarlos. - naranja_congelada

Si necesita una lista simple de tamaño 1:

List<String> strings = new ArrayList<String>(Collections.singletonList("A"));

Si necesita una lista de varios objetos:

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");

contestado el 27 de mayo de 17 a las 22:05

Con Guayaba puedes escribir:

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

En Guava también hay otros constructores estáticos útiles. Puedes leer sobre ellos aquí.

Respondido el 12 de diciembre de 17 a las 03:12

Estoy bastante seguro de que puedes hacer esto con solo java.util.Arrays como, List<String> names = Arrays.asList("Beckah", "Sam", "Michael"); - Becka

El método @beckah Arrays.asLists crea un objeto de tipo List, mientras que la pregunta es sobre la creación de ArrayList - Paweł Adamski

Con y arriba, como se sugiere en JEP 269: Métodos de fábrica de conveniencia para colecciones, esto podría lograrse usando literales de colección ahora con -

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

Set<String> set = Set.of("A", "B", "C");

Un enfoque similar se aplicaría a Map también -

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

que es similar a Propuesta de Literales de Colección según lo declarado por @coobird. También se aclara más en la JEP:


Alternativas

Los cambios de idioma se han considerado varias veces y se han rechazado:

Propuesta de Project Coin, 29 de marzo de 2009

Propuesta de Project Coin, 30 de marzo de 2009

Discusión de JEP 186 sobre lambda-dev, enero-marzo de 2014

Las propuestas de idiomas se dejaron de lado con preferencia a una propuesta basada en una biblioteca como se resume en este mensaje.

Relacionado: ¿Cuál es el punto de los métodos de fábrica de conveniencia sobrecargados para colecciones en Java 9?

Respondido el 20 de junio de 20 a las 10:06

Los literales de colección no llegaron a Java 8, pero es posible usar la API Stream para inicializar una lista en una línea bastante larga:

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

Si necesita asegurarse de que su List es un ArrayList:

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));

Respondido 04 Abr '14, 00:04

import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");

contestado el 12 de mayo de 10 a las 14:05

No quiero agregar una nueva dependencia solo para hacer eso. - macarrón

Eso es lo mismo que Collections.unmodifiableList(Arrays.asList("Buenos Aires", "Córdoba", "La Plata")), que se convierte unmodifiableList(asList("Buenos Aires", "Córdoba", "La Plata")) con importaciones estáticas. No necesita colecciones de Google para esto. - Christoffer Hammarström

No, no es lo mismo. Como ImmutableList está documentando su inmutabilidad en el tipo de resultado cuando unmodifiableList lo enmascara como una Lista normal. - david pedro

En lugar del inmutable, las colecciones de Google también ofrecen una lista de matrices mutables: Lista = Lists.newArrayList ("Buenos Aires", "Córdoba", "La Plata"); - L holanda

Vas a pasar eso ImmutableList a otros métodos que requieren Listy, de todos modos, ha perdido esa documentación. - Christoffer Hammarström

Podrías crear un método de fábrica:

public static ArrayList<String> createArrayList(String ... elements) {
  ArrayList<String> list = new ArrayList<String>();
  for (String element : elements) {
    list.add(element);
  }
  return list;
}

....

ArrayList<String> places = createArrayList(
  "São Paulo", "Rio de Janeiro", "Brasília");

Pero no es mucho mejor que tu primera refactorización.

Para una mayor flexibilidad, puede ser genérico:

public static <T> ArrayList<T> createArrayList(T ... elements) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : elements) {
    list.add(element);
  }
  return list;
}

respondido 04 mar '18, 21:03

Mire hacia atrás en la publicación original, está solicitando la inicialización de la matriz en una línea, no 7 líneas adicionales. - L holanda

@LeoHolanda: Estoy de acuerdo con crear métodos de fábrica para cada pequeña cosa es demasiado. Pero dependiente según la situación y la cantidad de veces que se utilizará ese método, podría tener sentido crearlo. La creación de capas de abstracción adicionales está destinada a remove complejidad, creando más significativo métodos que capturan el intención del diseñador. - Jordán

En Java 9 podemos inicializar fácilmente un ArrayList en una sola línea:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

or

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Este nuevo enfoque de Java 9 tiene muchas ventajas sobre los anteriores:

  1. Eficiencia del espacio
  2. Inmutabilidad
  3. A salvo de amenazas

Vea esta publicación para más detalles -> ¿Cuál es la diferencia entre List.of y Arrays.asList?

respondido 04 mar '18, 22:03

La forma más compacta de hacer esto es:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);

Respondido el 15 de diciembre de 14 a las 11:12

Simplemente use el siguiente código de la siguiente manera.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};

Respondido el 12 de diciembre de 17 a las 02:12

@bsd Puede usar este método para declarar la lista antes de ingresar cualquier método. Entonces, al definir variables de clase, el contenido se puede agregar a la lista sin tener que invocar un método para hacerlo. - Melwil

La inicialización de llaves dobles debe evitarse en la medida de lo posible. ver : stackoverflow.com/a/924326/760393 - Raúl

Con Colecciones Eclipse puedes escribir lo siguiente:

List<String> list = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");

También puede ser más específico sobre los tipos y si son mutables o inmutables.

MutableList<String> mList = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableList<String> iList = Lists.immutable.with("Buenos Aires", "Córdoba", "La Plata");

También puedes hacer lo mismo con Conjuntos y Bolsas:

Set<String> set = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableSet<String> mSet = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet<String> iSet = Sets.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Bag<String> bag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableBag<String> mBag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableBag<String> iBag = Bags.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Nota: Soy un committer de Eclipse Collections.

contestado el 01 de mayo de 19 a las 02:05

Aquí hay otra forma:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());

respondido 01 mar '17, 00:03

(Debería ser un comentario, pero demasiado largo, así que nueva respuesta). Como han mencionado otros, el Arrays.asList El método es de tamaño fijo, pero ese no es el único problema. Tampoco maneja muy bien la herencia. Por ejemplo, suponga que tiene lo siguiente:

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

Lo anterior da como resultado un error del compilador, porque List<B>(que es lo que devuelve Arrays.asList) no es una subclase de List<A>, aunque puede agregar objetos de tipo B a un List<A> objeto. Para evitar esto, debe hacer algo como:

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

Esta es probablemente la mejor manera de hacerlo, especialmente. si necesita una lista ilimitada o necesita usar herencia.

Respondido el 12 de diciembre de 17 a las 02:12

Puede utilizar las siguientes declaraciones:

Fragmento de código:

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);

Respondido el 20 de junio de 20 a las 10:06

Puede insertar la primera expresión para tener una solución compacta: letters = Arrays.asList(new String[]{"A", "B", "C"}); - Pavel Repin

Me gusta Tom dijo:

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Pero como se quejó de querer una ArrayList, primero debe saber que ArrayList es una subclase de List y simplemente podría agregar esta línea:

ArrayList<String> myPlaces = new ArrayList(places);

Aunque, eso podría hacer que te quejes de "rendimiento".

En ese caso, no tiene sentido para mí, por qué, dado que su lista está predefinida, no se definió como una matriz (ya que el tamaño se conoce en el momento de la inicialización). Y si esa es una opción para ti:

String[] places = {"Buenos Aires", "Córdoba", "La Plata"};

En caso de que no le importen las pequeñas diferencias de rendimiento, también puede copiar una matriz a una ArrayList de manera muy simple:

ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));

De acuerdo, pero en el futuro necesitas algo más que el nombre del lugar, también necesitas un código de país. Suponiendo que esta sigue siendo una lista predefinida que nunca cambiará durante el tiempo de ejecución, entonces es apropiado usar un enum set, que requeriría volver a compilar si la lista necesita cambiarse en el futuro.

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

se convertiría:

enum Places {
    BUENOS_AIRES("Buenos Aires",123),
    CORDOBA("Córdoba",456),
    LA_PLATA("La Plata",789);

    String name;
    int code;
    Places(String name, int code) {
      this.name=name;
      this.code=code;
    }
}

Enum tiene una estática values método que devuelve una matriz que contiene todos los valores de la enumeración en el orden en que se declaran, por ejemplo:

for (Places p:Places.values()) {
    System.out.printf("The place %s has code %d%n",
                  p.name, p.code);
}

En ese caso, supongo que no necesitaría su ArrayList.

PS Randyaa demostró otra forma agradable de usar el método de utilidad estática Colecciones.addAll.

contestado el 23 de mayo de 17 a las 13:05

Java 9 tiene el siguiente método para crear un inmutable lista:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

que se adapta fácilmente para crear una lista mutable, si es necesario:

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Hay métodos similares disponibles para Set y Map.

Respondido el 06 de diciembre de 16 a las 09:12

Es bueno que dijiste explícitamente "lista inmutable" y luego mostraste otro ejemplo de lista mutable porque deja claro cuál usar y cuándo. - teon

List<String> names = Arrays.asList("2","@2234","21","11");

Respondido el 23 de Septiembre de 15 a las 14:09

Sí, con la ayuda de Arrays, puede inicializar la lista de matrices en una línea,

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");

Respondido el 13 de Septiembre de 16 a las 06:09

Puedes usar StickyList de Cactus:

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Respondido el 25 de junio de 17 a las 18:06

Prueba con esta línea de código:

Collections.singletonList(provider)

contestado el 16 de mayo de 16 a las 15:05

Agrega una breve descripción de tu respuesta. - gustavo morales

En Java, no puedes hacer

ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Como se señaló, necesitaría hacer una inicialización de doble llave:

List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};

Pero esto puede obligarlo a agregar una anotación. @SuppressWarnings("serial") o generar un UUID serial que sea molesto. Además, la mayoría de los formateadores de código lo desenvolverán en múltiples declaraciones / líneas.

Alternativamente puedes hacer

List<String> places = Arrays.asList(new String[] {"x", "y" });

pero entonces es posible que desee hacer un @SuppressWarnings("unchecked").

También de acuerdo con javadoc debería poder hacer esto:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Pero no puedo compilarlo con JDK 1.6.

Respondido 13 Feb 12, 22:02

¡Equivocado! Tú puede haz la primera línea, y esa es la respuesta correcta por cierto - Bohemio ♦

Collections.singletonList(messageBody)

Si necesita tener una lista de un item!

Colecciones es desde java.util paquete.

Respondido 03 Abr '15, 10:04

La mejor forma de hacerlo:

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

Simplemente cree una función que pueda tener tantos elementos como desee y llámela para agregarlos en una línea.

contestado el 27 de mayo de 17 a las 22:05

Si pasa por todos los problemas, también puede convertirlo en un método de plantilla en lugar de usar simple Object. - Robert

Aquí está el código de Ábaco

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

Declaración: Soy el desarrollador de AbacusUtil.

Respondido el 27 de enero de 19 a las 22:01

Para mí, Arrays.asList () es el mejor y más conveniente. Siempre me gusta inicializar de esa manera. Si eres un principiante en las colecciones de Java, me gustaría que me refieras Inicialización de ArrayList

Respondido el 07 de diciembre de 14 a las 05:12

¿Por qué Arrays.asList () es mejor que crear una nueva ArrayList en una línea con add() ¿métodos? - IgorGanapolsky

¿Por qué no hacer una función de utilidad simple que haga esto?

static <A> ArrayList<A> ll(A... a) {
  ArrayList l = new ArrayList(a.length);
  for (A x : a) l.add(x);
  return l;
}

"ll"significa" lista literal ".

ArrayList<String> places = ll("Buenos Aires", "Córdoba", "La Plata");

Respondido el 04 de diciembre de 17 a las 11:12

podría usar Collections.addAll en lugar del bucle for. Además, si nombra el método list, el nombre no requiere explicación :) - Choquesoft

curiosamente no hay una sola línea con la otra sobrecargada Stream::collect el método está listado

ArrayList<String> places = Stream.of( "Buenos Aires", "Córdoba", "La Plata" ).collect( ArrayList::new, ArrayList::add, ArrayList::addAll );

Respondido 04 Oct 19, 16:10

De hecho, es posible hacerlo en una sola línea:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})

contestado el 27 de mayo de 17 a las 22:05

¿Puedo preguntar qué agrega esto a la pregunta? Esta respuesta ya está cubierta varias veces por otras respuestas. - Mística

En realidad, esta es una solución realmente mala ya que crea una LISTA RESUMEN. No podrá agregar nada más al contenedor. - Atais

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.