Quería crear una lista de opciones para 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, refactoré 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?

En realidad, probablemente la "mejor" forma de inicializar ArrayListes el método que escribió, ya que no necesita crear uno nuevo Listde ninguna 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 referirse a esa listinstancia.

Existen alternativas, como crear una clase interna anónima con un inicializador de instancia (también conocido como "inicialización de doble paréntesis"):

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

Sin embargo, no me gusta mucho ese método porque lo que termina es una subclase de la ArrayListcual 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 que se aceptara la propuesta de Collection Literals para Project Coin (estaba programada para ser introducida en Java 7, pero tampoco es probable que forme parte de Java 8):

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

Desafortunadamente, no lo ayudará aquí, ya que inicializará un inmutable en Listlugar de un ArrayList, y además, aún no está disponible, si alguna vez lo estará.

Sería más simple si simplemente lo declararas como List: ¿tiene que ser una 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 placeses inmutable (intentar cambiarlo provocará una UnsupportedOperationExceptionexcepción).

Para hacer una lista mutable que sea concreta ArrayList, puede crear una ArrayListdesde la lista inmutable:

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

La respuesta simple

En Java 9 o posterior, después List.of()se agregó:

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

Con Java 10 o posterior, esto se puede acortar con la varpalabra clave.

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

Esto le dará un inmutable List , por lo que no se puede cambiar.
Que es lo que quieres en la mayoría de los casos donde lo estás rellenando.

Java 8 o anterior:

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

Esto le dará un Listrespaldo de una matriz, por lo que no puede cambiar la longitud.
Pero puedes llamar List.set, así que todavía es mutable .

Puede Arrays.asListacortar aún más 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+Entery selecciona Static import method....

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

Usando Streams

¿Por qué tiene que ser un List?
Con Java 8 o posterior, puede usar uno Streamque sea 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 Streama un List:

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

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

Pero preferiblemente, solo use el Streamsin recogerlo a List.

Si realmente necesitas unjava.util.ArrayList

(Probablemente no.)
Para citar JEP 269 (el énfasis es 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 desea tanto una rellenar previamente ArrayList y agregar a ella después (¿por qué?), El uso

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 usando 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 Streamdirectamente en lugar de recopilarlo en a List.

Programa para interfaces, no para implementaciones

Dijiste que declaraste la lista como ArrayListen tu código, pero solo deberías hacerlo si estás usando algún miembro ArrayListque no está en List.

Lo que probablemente no estés haciendo.

Por lo general, sólo debe declarar variables por la interfaz más general que se va a utilizar (por ejemplo Iterable, Collectiono List), e inicializar con la aplicación específica (por ejemplo ArrayList, LinkedListo 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 está pasando un ArrayLista un 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 una variable InputStreama pesar de que generalmente es a FileInputStreamo a BufferedInputStream, porque un día pronto usted u otra persona querrán usar otro tipo de InputStream.

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");

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í .

Los literales de colección no llegaron a Java 8, pero es posible usar Stream API 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 Listes un ArrayList:

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

Con java-9y más arriba, como se sugiere en JEP 269: Convenience Factory Methods for Collections , 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");

También se aplicaría un enfoque similar Map:

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

que es similar a la propuesta de Collection Literals según lo indicado por @coobird. Más aclarado en el JEP también:

Alternativas

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

Propuesta de proyecto de moneda, 29 de marzo de 2009

Propuesta de proyecto de moneda, 30 de marzo de 2009

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

Las propuestas de lenguaje se reservaron con preferencia a una propuesta basada en la 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

import com.google.common.collect.ImmutableList;

....

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

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;
}

En Java 9, podemos inicializar fácilmente ArrayListen una sola línea:

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

o

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 Espacial
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?

La forma más compacta de hacer esto es:

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

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

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

Con Eclipse Collections puede 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 puede 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 para Eclipse Collections.

Aquí hay otra forma:

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

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

class A{}
class B extends A{}

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

Lo anterior genera un error de compilación 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 la herencia.

Puede usar las siguientes declaraciones:

Fragmento de código:

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

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

Como dijo Tom :

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 puede agregar esta línea:

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

Sin embargo, 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));

Está bien, pero en el futuro necesita un poco más que el nombre del lugar, también necesita un código de país. Asumiendo que esta sigue siendo una lista predefinida que nunca cambiará durante el tiempo de ejecución, entonces es apropiado usar un enumconjunto, que requeriría una nueva compilación si la lista necesita ser cambiada 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;
    }
}

Las valuesenumeraciones tienen un método estático 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ías tu ArrayList.

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

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

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"));

Métodos similares están disponibles para Sety Map.

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

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

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

Puedes usar StickyListdesde Cactoos :

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

Pruebe con esta línea de código:

Collections.singletonList(provider)

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 en serie que es 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 una @SuppressWarnings("unchecked").

También según javadoc, deberías poder hacer esto:

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

Pero no puedo hacer que se compile con JDK 1.6.

Collections.singletonList(messageBody)

¡Si necesita tener una lista de un artículo !

Colecciones es del paquete java.util .

La mejor manera 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.

Aquí está el código de AbacusUtil

// 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.

Para mí, Arrays.asList () es el mejor y conveniente. Siempre me gusta inicializar de esa manera. Si es un principiante en Java Collections, me gustaría que consulte la inicialización de ArrayList

¿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");

Curiosamente, no aparece una línea con el otro método sobrecargadoStream::collect

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

En realidad, es posible hacerlo en una línea:

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