java - metodos - Inicialización de un ArrayList en una línea

imprimir arraylist java

Question

Quiero crear una lista de opciones para propósitos 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 he refaccionado 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?

Answer 1

La respuesta simple

En Java 8 o anterior:

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

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

En Java 9:

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

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

La respuesta mas corta

Puede hacer que 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 automáticamente lo hará por usted.
Por ejemplo, en IntelliJ IDEA, presiona Alt+Enter y selecciona Static import method...

Sin embargo, no recomiendo acortar el método de Java 9 List.of , ya que solo se vuelve confuso.
List.of ya es lo suficientemente corto y se lee bien.

Usando Stream s

¿Por qué tiene que ser una List ?
Con Java 8 o posterior puedes usar un Stream que es más flexible:

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

Puedes concatenar Stream s:

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

O puedes ir de un Stream a una List :

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

Pero preferiblemente, solo use el Stream sin recopilarlo en una List .

Si realmente necesitas específicamente un java.util.ArrayList

(Probablemente no).
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. Generalmente, 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 rellenar previamente un ArrayList y agregarlo después (¿por qué?), Use

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

o en Java 9:

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

o utilizando Stream :

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

Pero, una vez más, es mejor usar el Stream directamente en lugar de recopilarlo en una List .

Programa a interfaces, no a implementaciones.

Dijo que había declarado la lista como una ArrayList en su código, pero solo debería hacerlo si está utilizando algún miembro de ArrayList que no esté en la List .

Lo que es más probable que no estés haciendo.

Por lo general, solo debe declarar las variables por la interfaz más general que va a usar (por ejemplo, Iterable , Collection o List ), e inicializarlas con la implementación específica (por ejemplo, ArrayList , LinkedList o 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:

// Iterable if you just need iteration, for (String s : strings):
Iterable<String> strings = new ArrayList<>();   

// Collection if you also need .size() or .stream():
Collection<String> strings = new ArrayList<>(); 

// List if you also need .get(index):
List<String> strings = new ArrayList<>();       

// Don''t declare a specific list implementation
// unless you''re sure you need it:
ArrayList<String> strings = new ArrayList<>();  // You don''t need ArrayList

Otro ejemplo sería siempre declarar a la variable un InputStream , aunque normalmente sea un FileInputStream o un BufferedInputStream , porque un día pronto usted u otra persona querrá usar algún otro tipo de InputStream .

Answer 2

¿Por qué no hacer una función de utilidad simple que hace 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");

Answer 3

(Debería ser un comentario, pero demasiado largo, así que nueva respuesta). Como han mencionado otros, el método Arrays.asList es de tamaño fijo, pero ese no es el único problema con él. Tampoco maneja muy bien la herencia. Por ejemplo, supongamos 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, ya que 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 objeto List<A> . Para solucionar esto, necesitas hacer algo como:

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

Esta es probablemente la mejor manera de hacer esto, esp. si necesita una lista ilimitada o necesita utilizar la herencia.

Answer 4

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.

Answer 5

Aquí hay otra manera:

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

Answer 6

Como 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 la Lista y que simplemente podría agregar esta línea:

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

Aunque, eso podría hacerte quejarte de ''rendimiento''.

En ese caso, no tiene sentido para mí, porque ya 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 un ArrayList de manera muy simple:

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

De acuerdo, pero en el futuro necesita algo más que el nombre del lugar, también necesita un código de país. Suponiendo que esta es todavía una lista predefinida que nunca cambiará durante el tiempo de ejecución, entonces es apropiado usar un conjunto de enum , lo que requeriría una nueva compilación si fuera necesario cambiar la lista 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;
    }
}

Los Enum tienen un método de values estáticos 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 manera agradable usando el método de utilidad estática Collections.addAll .

Answer 7

Con Guava puedes escribir:

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

En la guayaba también hay otros constructores estáticos útiles. Puedes leer sobre ellos here .

Answer 8

Con Eclipse Collections (anteriormente GS 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 puedes hacer lo mismo con Sets y Bolsos:

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 comendador de Eclipse Collections.

Answer 9

Con Java 9 , como se sugiere en la Propuesta de Mejora JDK - 269 , esto podría lograrse usando los literales de colección ahora como -

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

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

También un enfoque similar se aplicaría al Map también.

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

que es similar a la propuesta de Collection Literals como lo afirma @coobird también. Se aclara más en el documento JEP también -

Alternativas

Los cambios de idioma han sido considerados varias veces, y rechazados:

Proyecto Coin Proposal, 29 de marzo de 2009.

Proyecto Coin Proposal, 30 de marzo de 2009.

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

Las propuestas de lenguaje se dejaron de lado en lugar de una propuesta de biblioteca, como se resume en este message.

Leer más => ¿Cuál es el punto de los métodos de Convenience Factory sobrecargados para colecciones en Java 9?

Answer 10

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

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 del espacio
2. Immutability
3. A salvo de amenazas

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

Answer 11

En Java, no puedes hacer

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

Como se señaló, tendría que hacer una inicialización de doble refuerzo:

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

Pero esto puede forzarle 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 desempaquetarán en varias 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ías poder hacer esto:

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

Pero no puedo compilarlo con JDK 1.6.

Answer 12

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

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

Answer 13

En realidad, probablemente la "mejor" manera de inicializar ArrayList es el método que escribió, ya que no necesita crear una nueva List de ninguna manera:

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

El problema es que se requiere bastante escritura para referirse a esa instancia de list .

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

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

Sin embargo, no me gusta mucho ese método porque lo que ArrayList es 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 excesivo. .

Lo que hubiera sido bueno sería si la propuesta de Collection Literals para Project Coin fuera aceptada (estaba programada para ser introducida en Java 7, pero tampoco es probable que sea parte de Java 8):

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

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

Answer 14

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 Set y Map .

Answer 15

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.

Answer 16

Los literales de colección no llegaron a Java 8, pero es posible usar la API de 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 sea ​​una ArrayList :

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

Answer 17

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

Answer 18

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

Answer 19

Prueba con esta línea de código:

Collections.singletonList(provider)

Answer 20

Puede utilizar las siguientes afirmaciones:

Fragmento de código:

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

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

Answer 21

Puedes usar StickyList de Cactoos :

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

Answer 22

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

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

Answer 23

Sería más sencillo si solo lo declarara como una List , ¿tiene que ser una lista de arreglos?

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

O si solo tienes un elemento:

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

Esto significaría que los places son inmutables (tratar de cambiarlos provocará que se UnsupportedOperationException una excepción UnsupportedOperationException ).

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

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

Answer 24

Si necesita una lista simple de tamaño 1:

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

Si necesitas una lista de varios objetos:

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

Answer 25

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

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

Answer 26

Sobre la forma más compacta de hacer esto es:

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

Answer 27

Collections.singletonList(messageBody)

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

Las colecciones son del paquete java.util .

Answer 28

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

Answer 29

import com.google.common.collect.ImmutableList;

....

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

Answer 30

public static <T> List<T> asList(T... a) {
    return new ArrayList<T>(a);
}

Esta es la implementación de Arrays.asList , por lo que podría ir con

ArrayList<String> arr = (ArrayList<String>) Arrays.asList("1", "2");