Pregunta Características ocultas de Java - ArrayList / aclaración de inicializadores de instancia


En el Características ocultas de Java pregunta, estaba interesado La respuesta sobre los inicializadores de instancia..

Me preguntaba cómo modificar esta línea:

List<Integer> numbers = new ArrayList<Integer>(){{ add(1); add(2); }};

para hacer que realice el mismo trabajo con Arraylists anidados:

ArrayList<ArrayList<Integer>> numbers = ...

¿es eso posible?


5
2018-05-26 18:35


origen


Respuestas:


List<Integer> numbers = new ArrayList<Integer>(){{ add(1); add(2); }};

Realmente no recomiendo este enfoque, ya que crea una clase (anónima) sin una buena razón.

Utilizar cualquiera:

List<Integer> numbers = Arrays.asList(1, 2);

o

List<Integer> numbers = new ArrayList<Integer>(Arrays.asList(1, 2));

Para 2 niveles, puedes usar:

List<List<Integer>> numbers = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(2,3,4));

Con una importación estática, incluso podría reducirlo a esto, si realmente desea:

List<List<Integer>> numbers = asList(asList(1, 2), asList(2,3,4));

4
2018-05-26 18:45



La inicialización de doble refuerzo se volvió mucho menos interesante para las listas ahora que Arrays.asList toma varargs, puede hacer esto en su lugar:

List<List<Integer>> numbers = new ArrayList<List<Integer>>();
numbers.add(Arrays.asList(1,2));
numbers.add(Arrays.asList(3,4));

O combínelo con la inicialización de llaves dobles como esta:

List<List<Integer>> numbers = new ArrayList<List<Integer>>() {{add(Arrays.asList(1,2)); add(Arrays.asList(3,4));}};

pero si cabe en una línea depende de las pautas de formato de código de su proyecto. Esto es tan horriblemente detallado que las alternativas comienzan a verse bien. Como poner los números en una cadena y analizarlos. O cambiando a Scala, Groovy o Clojure, todos ellos compatibles con la sintaxis de la lista literal.


3
2018-05-26 18:40



Y, por supuesto, puedes hacer lo mismo con las ArrayLists internas: aunque creo que se vuelve bastante ilegible ...

    List<ArrayList<Integer>> numbers = new ArrayList<ArrayList<Integer>>()
    {
        {
            add(new ArrayList<Integer>()
            {
                {
                    add(1);
                    add(2);
                }
            });
            add(new ArrayList<Integer>()
            {
                {
                    add(1);
                    add(2);
                }
            });
        }
    };

aunque no es mucho más larga o peor que la forma convencional (¡dependiendo de tu estilo de corsé!)

    List<ArrayList<Integer>> numbers = new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    ArrayList<Integer> list2 = new ArrayList<Integer>();
    list1.add(1);
    list1.add(2);
    list2.add(1);
    list2.add(2);
    numbers.add(list1);
    numbers.add(list2);

El enfoque Arrays.asList (1, 2) dado en otras respuestas parece el mejor de todos.


2
2018-05-26 18:42



No usaría este lenguaje para "simplificar" ArrayList declaraciones Se ve bien, pero crea innecesariamente una subclase anónima de ArrayList, y se ve demasiado "mágico" para mi gusto ... Quieres un código que sea legible y comprensible para el próximo desarrollador.

En su lugar, debería considerar el uso de una biblioteca como Google Guava.

Aquí hay un ejemplo usando guayabas. Lists.newArrayList (elementos E ...) método de utilidad:

    import com.google.common.collect.Lists;


    List<ArrayList<Integer>> numbers = Lists.newArrayList(
            Lists.newArrayList(1, 2),
            Lists.newArrayList(3, 4)
    );

O, mejor aún, usando sólo el List interfaz en el lado izquierdo (debe evitar el uso de clases concretas en sus declaraciones de variables):

    import com.google.common.collect.Lists;


    List<List<Integer>> numbers = Lists.<List<Integer>>newArrayList(
            Lists.newArrayList(1, 2),
            Lists.newArrayList(3, 4)
    );

Si sabes que estas listas serán inmutables, es aún mejor usarlas ImmutableList:

    import com.google.common.collect.ImmutableList;


    List<List<Integer>> numbers = ImmutableList.<List<Integer>>of(
            ImmutableList.of(1, 2),
            ImmutableList.of(3, 4)
    );

2
2018-05-26 18:47



Simplemente reemplace int con objeto de ArrayList<integer>

List<ArrayList<Integer>> numbers = new ArrayList<ArrayList<Integer>>() {

            {
                add(new ArrayList<Integer>());
                add(new ArrayList<Integer>());
            }
        };

1
2018-05-26 18:37