Crear ArrayList a partir de una matriz

Tengo una matriz que se inicializa como:

Element[] array = {new Element(1), new Element(2), new Element(3)};

Me gustaría convertir esta matriz en un objeto del ArrayList clase.

ArrayList<Element> arraylist = ???;

preguntado Oct 01 '08, 15:10

En Java9 -> Lista list = List.of ("Hola", "Mundo", "de", "Java"); -

@MarekM Esta respuesta es incorrecta, ya que no devuelve un ArrayList. The Poster pidió específicamente eso. -

Creo que no minó usando la interfaz List, porque es la mejor práctica. Pero si lo desea aquí es - new ArrayList <> (List.of ("Hola", "Mundo", "de", "Java")); -

El punto no se trata de usar la interfaz, el punto es que en su solución, la lista devuelta no se puede modificar. Eso podría ser un problema mayor, y una razón por la que solicitó una ArrayList:

30 Respuestas

new ArrayList<>(Arrays.asList(array));

Respondido 18 Feb 20, 04:02

Sí. Y en el caso (más común) en el que solo desea una lista, el new ArrayList La llamada también es innecesaria. - Calum

@Luron - solo usa List<ClassName> list = Arrays.asList(array) - Piscina

@Calum y @Pool: como se indica a continuación en la respuesta de Alex Miller, usando Arrays.asList(array) sin pasarlo a un nuevo ArrayList El objeto fijará el tamaño de la lista. Una de las razones más comunes para usar un ArrayList es poder cambiar dinámicamente su tamaño, y su sugerencia evitaría esto. - Jockey de código

Arrays.asList () es una función horrible, y nunca debe usar su valor de retorno tal como está. Rompe la plantilla de la Lista, así que utilícela siempre en la forma indicada aquí, incluso si parece redundante. Buena respuesta. - Adam

@Adam Por favor, estudie el javadoc para java.util.List. El contrato para agregar les permite lanzar una UnsupportedOperationException. docs.oracle.com/javase/7/docs/api/java/util/… Es cierto que, desde una perspectiva orientada a objetos, no es muy agradable que muchas veces tenga que conocer la implementación concreta para usar una colección; esta fue una elección de diseño pragmática para mantener el marco simple. - lbalazscs

Dado:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

La respuesta más sencilla es hacer:

List<Element> list = Arrays.asList(array);

Esto funcionará bien. Pero algunas advertencias:

  1. La lista devuelta por asList tiene tamaño fijo. Por lo tanto, si desea poder agregar o eliminar elementos de la lista devuelta en su código, deberá ajustarlo en un nuevo ArrayList. De lo contrario, obtendrás un UnsupportedOperationException.
  2. La lista devuelta de asList() está respaldado por la matriz original. Si modifica la matriz original, la lista también se modificará. Esto puede resultar sorprendente.

respondido 07 nov., 14:17

¿Cuál es la complejidad temporal de ambas operaciones? Me refiero con y sin usar una construcción de lista de matrices explícita. - maldito

Arrays.asList () simplemente crea una ArrayList envolviendo la matriz existente para que sea O (1). - Alex Miller

Envolver en una nueva ArrayList () hará que todos los elementos de la lista de tamaño fijo sean iterados y agregados a la nueva ArrayList, así como O (n). - Alex Miller

la implementación de List devuelta por asList () no implementa varios de los métodos de List (como add (), remove (), clear (), etc ...) que explica la UnsupportedOperationException. definitivamente una advertencia ... - sethro

Cuando la pregunta pide "un objeto de la clase ArrayList", creo que es razonable suponer que la clase a la que se refiere es java.util.ArrayList. Arrays.asList en realidad devuelve un java.util.Arrays.ArrayList que no es un instanceof la otra clase. Entonces, una tercera advertencia es que si intenta usarlo en un contexto que requiera lo anterior, no funcionará. - Dave L.

(hilo antiguo, pero solo 2 centavos ya que ninguno menciona Guava u otras bibliotecas y algunos otros detalles)

Si puede, use guayaba

Vale la pena señalar el método Guava, que simplifica enormemente estas travesuras:

Uso

Para una lista inmutable

Utiliza ImmutableList clase y su of() y copyOf() métodos de fábrica (los elementos no pueden ser nulos):

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

Para una lista mutable

Utiliza Lists clase y su newArrayList() métodos de fábrica:

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

Tenga en cuenta también los métodos similares para otras estructuras de datos en otras clases, por ejemplo en Sets.

¿Por qué guayaba?

El principal atractivo podría ser reducir el desorden debido a los genéricos para la seguridad de tipos, como el uso de la guayaba métodos de fábrica Permitir que los tipos se infieran la mayor parte del tiempo. Sin embargo, este argumento tiene menos fundamento desde que llegó Java 7 con el nuevo operador de diamantes.

Pero no es la única razón (y Java 7 aún no está en todas partes): la sintaxis abreviada también es muy útil, y los inicializadores de métodos, como se vio arriba, permiten escribir código más expresivo. Lo haces en una llamada de Guava lo que toma 2 con las colecciones de Java actuales.


Si no puedes ...

Para una lista inmutable

Usa los JDK Arrays clase y su asList() método de fábrica, envuelto con un Collections.unmodifiableList():

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

Tenga en cuenta que el tipo devuelto para asList() es una List usando un concreto ArrayList implementación, pero No lo es java.util.ArrayList. Es un tipo interno, que emula un ArrayList pero en realidad hace referencia directamente a la matriz pasada y la hace "escribir" (las modificaciones se reflejan en la matriz).

Prohíbe modificaciones a través de algunos de los List Los métodos de API simplemente extendiendo un AbstractList (por lo tanto, agregar o eliminar elementos no es compatible), sin embargo, permite llamadas a set() para anular elementos. Por lo tanto, esta lista no es realmente inmutable y es una llamada a asList() debe estar envuelto con Collections.unmodifiableList().

Vea el siguiente paso si necesita una lista mutable.

Para una lista mutable

Igual que arriba, pero envuelto con un real java.util.ArrayList:

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

Con fines educativos: el buen método manual

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}

Respondido el 13 de diciembre de 16 a las 20:12

+1 Pero tenga en cuenta que el List devuelto por Arrays.asList es mutable en el sentido de que todavía puedes set elementos, simplemente no se puede cambiar de tamaño. Para listas inmutables sin guayaba, puede mencionar Collections.unmodifiableList. - Paul Bellora

@haylem En tu sección Con fines educativos: el buen método manual, Su arrayToList para Java 1.5+ es incorrecto. Estás instanciando listas de Stringy tratando de recuperar cadenas de la matriz dada, en lugar de usar el tipo de parámetro genérico, T. Aparte de eso, buena respuesta, y +1 por ser el único que incluye la forma manual. - afsantos

Cambiaré el nombre de su sección "Si no puede ... / Para una lista inmutable" a "Para una lista no modificable", ya que puede ser mutado por cambios posteriores en la matriz envuelta. Todavía O(1), pero por inmutabilidad tienes que hacer una copia, por ejemplo, por Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array))). - maaartinus

Dado que esta pregunta es bastante antigua, me sorprende que nadie sugiera la forma más simple hasta ahora:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

A partir de Java 5, Arrays.asList() toma un parámetro varargs y no tiene que construir la matriz explícitamente.

Respondido el 29 de Septiembre de 16 a las 19:09

En particular, List<String> a = Arrays.asList("first","second","third") - 18446744073709551615

new ArrayList<T>(Arrays.asList(myArray));

Asegurar que myArray es del mismo tipo que T. Obtendrá un error del compilador si intenta crear un List<Integer> de una matriz de int, por ejemplo.

Respondido 13 Feb 17, 20:02

Otra forma (aunque esencialmente equivalente a la new ArrayList(Arrays.asList(array)) rendimiento de la solución:

Collections.addAll(arraylist, array);

Respondido 04 Abr '12, 03:04

Java 9

In Java 9, puedes usar List.of método de fábrica estática para crear un List literal. Algo parecido a lo siguiente:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

Esto devolvería un inmutable lista que contiene tres elementos. Si quieres un mudable lista, pase esa lista a la ArrayList constructor:

new ArrayList<>(List.of(// elements vararg))

JEP 269: Métodos de fábrica de conveniencia para colecciones

JEP 269 proporciona algunos métodos de fábrica de conveniencia para Colecciones de Java API. Estos métodos inmutables de fábrica estática están integrados en el List, Sety Map interfaces en Java 9 y posteriores.

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

List.of () no devolverá una instancia de java.util.ArrayList, como se solicitó en la pregunta original. Por lo tanto, solo la segunda opción es una respuesta válida. - tquadrat

Probablemente solo necesite una List, no una ArrayList. En ese caso, puede hacer:

List<Element> arraylist = Arrays.asList(array);

Respondido 01 Oct 08, 18:10

Eso estará respaldado por la matriz de entrada original, por lo que (probablemente) desee envolverlo en una nueva ArrayList. - Bill el lagarto

Tenga cuidado con esta solución. Si miras, Arrays NO devuelve un verdadero java.util.ArrayList. Devuelve una clase interna que implementa los métodos requeridos, pero no puede cambiar los miembros de la lista. Es simplemente una envoltura alrededor de una matriz. - Mikezx6r

Puedes lanzar la Lista elemento a una ArrayList - monjes

@ Mikezx6r: pequeño corrección: es una lista de tamaño fijo. Puede cambiar los elementos de la lista (set método), no puede cambiar el tamaño de la lista (no add or remove elementos)! - user85421

Sí, con la salvedad de que depende de lo que quieras hacer con la lista. Vale la pena señalar que si el OP simplemente quiere iterar a través de los elementos, la matriz no tiene que convertirse en absoluto. - PaulMurrayCbr

Otra actualización, casi terminando el año 2014, también puedes hacerlo con Java 8:

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

Se guardarían algunos caracteres, si esto pudiera ser solo un List

List<Element> list = Stream.of(myArray).collect(Collectors.toList());

respondido 25 nov., 14:23

Probablemente sea mejor no depender de la implementación, pero Collectors.toList() en realidad devuelve un ArrayList. - bcsb1001

uso incorrecto de Stream. de (...); que creará una secuencia de un elemento. Utilice Arrays.stream en su lugar - Patrick Parker

No lo creo, las 2 opciones son válidas pero Arrays.stream es ligeramente 'mejor' ya que puedes crearlo con un tamaño fijo, usando el método de sobrecarga con los argumentos 'start', 'end'. Ver también: stackoverflow.com/a/27888447/2619091 - yamilmedina

Si utiliza :

new ArrayList<T>(Arrays.asList(myArray));

pueden Para crear y llenar dos listas! Llenar dos veces una lista grande es exactamente lo que no desea hacer porque creará otra Object[] matriz cada vez que se necesite ampliar la capacidad.

Afortunadamente, la implementación de JDK es rápida y Arrays.asList(a[]) está muy bien hecho. Crea una especie de ArrayList llamada Arrays.ArrayList donde los datos de Object [] apuntan directamente a la matriz.

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

El lado peligroso es que si cambia la matriz inicial, cambia la lista! ¿Estás seguro de que quieres eso? Tal vez si tal vez no.

Si no es así, la forma más comprensible es hacer esto:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

O como dijo @glglgl, puede crear otra ArrayList independiente con:

new ArrayList<T>(Arrays.asList(myArray));

Me encanta usar Collections, Arrayso Guayaba. Pero si no encaja, o no lo siente, simplemente escriba otra línea poco elegante en su lugar.

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

No veo la diferencia fundamental entre su ciclo al final de la respuesta y el new ArrayList<T>(Arrays.asList(myArray)); parte que desaconseja utilizar. Ambos hacen lo mismo y tienen la misma complejidad. - glglgl

La colección uno crea un puntero al principio de la matriz. Mi bucle crea muchos punteros: uno para cada miembro de la matriz. Entonces, si la matriz original cambia, mis punteros aún se dirigen hacia los valores anteriores. - Nicolás Zozol

new ArrayList<T>(Arrays.asList(myArray)); hace lo mismo, copia el asList a una ArrayList... - glglgl

In Java 9 puedes usar:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

Respondido 12 ago 17, 14:08

Tenga en cuenta que esto no es una ArrayList, como se preguntó explícitamente. - Dorian Gray

De acuerdo con la pregunta, la respuesta usando java 1.7 es:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

Sin embargo, es mejor usar siempre la interfaz:

List<Element> arraylist = Arrays.<Element>asList(array);

contestado el 18 de mayo de 15 a las 01:05

// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

Respondido el 07 de enero de 14 a las 10:01

Puedes convertir usando diferentes métodos

  1. List<Element> list = Arrays.asList(array);

  2. List<Element> list = new ArrayList();
    Collections.addAll(list, array);

  3. Arraylist list = new Arraylist();
    list.addAll(Arrays.asList(array));

Para obtener más detalles, puede consultar http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html

Respondido el 18 de junio de 16 a las 19:06

Desde Java 8 hay una forma más fácil de transformar:

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

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}

Respondido el 16 de junio de 20 a las 11:06

como todos dijeron, esto lo hará

 new ArrayList<>(Arrays.asList("1","2","3","4"));

y la forma más común de crear una matriz es observableArrays

ObservableList: Una lista que permite a los oyentes realizar un seguimiento de los cambios cuando ocurren.

para Java SE puedes probar

FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));

eso es de acuerdo con Documentos de Oracle

observableArrayList () Crea una nueva lista observable vacía respaldada por una lista de matrices. observableArrayList (E ... items) Crea una nueva lista de matrices observables con elementos agregados.

Actualizar Java 9

también en Java 9 es un poco fácil:

List<String> list = List.of("element 1", "element 2", "element 3");

Respondido el 05 de diciembre de 18 a las 15:12

También puede hacerlo con stream en Java 8.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 

Respondido 06 Feb 16, 11:02

A partir del java 8, Collectors.toList() devolverá un ArrayList. Sin embargo, esto puede diferir en futuras versiones de Java. Si desea un tipo específico de colección, utilice Collectors.toCollection() en su lugar, donde puede especificar qué tipo exacto de colección le gustaría crear. - Raja Anbazhagan

  1. Si vemos la definición de Arrays.asList() método obtendrá algo como esto:

     public static <T> List<T> asList(T... a) //varargs are of T type. 
    

    Entonces, podrías inicializar arraylist Me gusta esto:

     List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
    

    Nota: : cada new Element(int args) se tratará como un objeto individual y se puede pasar como un var-args.

  2. También podría haber otra respuesta para esta pregunta.
    Si ve una declaración para java.util.Collections.addAll() método obtendrá algo como esto:

    public static <T> boolean addAll(Collection<? super T> c, T... a);
    

    Entonces, este código también es útil para hacerlo

    Collections.addAll(arraylist, array);
    

respondido 13 mar '20, 11:03

Otra forma sencilla es agregar todos los elementos de la matriz a una nueva ArrayList usando un bucle for-each.

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);

Respondido el 16 de diciembre de 15 a las 23:12

Si la matriz es de tipo primitivo, las respuestas dadas no funcionarán. Pero desde Java 8 puedes usar:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());

Respondido 10 Jul 17, 05:07

esta solución no parece funcionar con char matriz, tampoco. - pixelmaster

Puedes hacerlo en java 8 de la siguiente manera

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

Respondido 02 ago 17, 17:08

Votado en contra porque ese elenco parece muy peligroso. nada especifica que el tipo de lista que se devuelve es en realidad una ArrayList, como dice el javadoc: "No hay garantías sobre el tipo, mutabilidad, serialización o seguridad de subprocesos de la Lista devuelta" - Dorian Gray

Si desea crear explícitamente una ArrayList, intente esto: ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new)); - Dorian Gray

Aunque hay muchas respuestas perfectamente escritas a esta pregunta, agregaré mis entradas.

Di que tienes Element[] array = { new Element(1), new Element(2), new Element(3) };

La nueva ArrayList se puede crear de las siguientes maneras

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

Y son muy compatibles con todas las operaciones de ArrayList.

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

Pero las siguientes operaciones devuelven solo una vista de lista de una ArrayList y no una ArrayList real.

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

Por tanto, darán error al intentar realizar algunas operaciones ArrayList

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

Más sobre la representación de lista de matriz enlace.

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

La forma más sencilla de hacerlo es agregando el siguiente código. Tratado y probado.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

contestado el 03 de mayo de 17 a las 11:05

Otra solución Java8 (Es posible que me haya perdido la respuesta entre el grupo grande. Si es así, mis disculpas). Esto crea una ArrayList (a diferencia de una Lista), es decir, uno puede eliminar elementos

package package org.something.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

La salida es ...
Hola
mundo

Respondido el 20 de junio de 17 a las 11:06

Podemos convertir fácilmente una matriz a ArrayList. Usamos la interfaz de Colección addAll() método con el propósito de copiar contenido de una lista a otra.

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));

respondido 18 mar '18, 22:03

Esto es menos eficiente que la respuesta aceptada de 9 años. - charles-allen

Uno de ArrayLists constructores acepta un ? extends Collection<T> argumento, haciendo la llamada a addAll redundante. - Tamoghna Chowdhury

Utilice el siguiente código para convertir una matriz de elementos en una ArrayList.

Element[] array = {new Element(1), new Element(2), new Element(3)};

ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
    elementArray.add(array[i]);
}

Respondido el 16 de enero de 19 a las 03:01

Matriz de objetos dada:

Element[] array = {new Element(1), new Element(2), new Element(3) , new Element(2)};

Convertir matriz en lista:

    List<Element> list = Arrays.stream(array).collect(Collectors.toList());

Convertir Array en ArrayList

    ArrayList<Element> arrayList = Arrays.stream(array)
                                       .collect(Collectors.toCollection(ArrayList::new));

Convertir matriz en LinkedList

    LinkedList<Element> linkedList = Arrays.stream(array)
                     .collect(Collectors.toCollection(LinkedList::new));

Lista de impresión:

    list.forEach(element -> {
        System.out.println(element.i);
    });

SALIDA

1

2

3

Respondido el 07 de Septiembre de 19 a las 23:09

Ya todo el mundo ha dado una buena respuesta a su problema. Ahora, a partir de todas las sugerencias, debe decidir cuál se ajustará a sus necesidades. Hay dos tipos de recopilación que debe conocer. Una es la colección sin modificar y la otra colección que le permitirá modificar el objeto más tarde.

Entonces, aquí daré un breve ejemplo para dos casos de uso.

  • Creación de colección inmutable: cuando no desea modificar el objeto de colección después de la creación

    List<Element> elementList = Arrays.asList(array)

  • Creación de colección mutable: cuando desee modificar el objeto de colección creado después de la creación.

    List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));

Respondido 25 Jul 17, 09:07

Lista elementList = Arrays.asList (matriz) crea una envoltura sobre la matriz original que hace que la matriz original esté disponible como Lista. Por lo tanto, se crea un objeto contenedor, no se copia nada de la matriz original. Por lo tanto, no se permiten operaciones como agregar o eliminar elementos. - Priyanka

Tenga en cuenta que su "colección inmutable" no es realmente inmutable: el List devuelto por Arrays.asList es solo un envoltorio sobre la matriz original y permite acceder y modificar elementos individuales a través de get y set. Probablemente debería aclarar que quiere decir "no agregar ni eliminar elementos" en lugar de "inmutable", lo que significa no cambiar en absoluto. - Tamoghna Chowdhury

La clase Arrays de Java 8 proporciona un método stream () que tiene versiones sobrecargadas que aceptan tanto matrices primitivas como matrices de objetos.

/**** Converting a Primitive 'int' Array to List ****/

int intArray[] = {1, 2, 3, 4, 5};

List<Integer> integerList1 = Arrays.stream(intArray).boxed().collect(Collectors.toList());

/**** 'IntStream.of' or 'Arrays.stream' Gives The Same Output ****/

List<Integer> integerList2 = IntStream.of(intArray).boxed().collect(Collectors.toList());

/**** Converting an 'Integer' Array to List ****/

Integer integerArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

List<Integer> integerList3 = Arrays.stream(integerArray).collect(Collectors.toList());

contestado el 19 de mayo de 19 a las 14:05

El siguiente código parece una buena forma de hacer esto.

new ArrayList<T>(Arrays.asList(myArray));

Respondido el 04 de diciembre de 19 a las 10:12

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