metodos - matriz de arraylist java

Crear ArrayList desde la matriz

Question

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 de la clase ArrayList.

ArrayList<Element> arraylist = ???;

Answer 1

Otra solución Java8 (es posible que haya perdido la respuesta entre el gran conjunto. Si es así, mis disculpas). Esto crea una ArrayList (a diferencia de una Lista), es decir, se pueden 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

Answer 2

Java 9

En Java 9 , puede utilizar el método de fábrica estático List.of para crear un literal de List . Algo como lo siguiente:

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

Esto devolvería una lista immutable contiene tres elementos. Si desea una lista mutable , pase esa lista al constructor ArrayList :

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 Java Collections API. Estos inmutables métodos de fábrica estática están integrados en las interfaces de List , Set y Map en Java 9 y posteriores.

Answer 3

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

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

   Entonces, podrías inicializar arraylist así:

    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. Puede haber otra respuesta para esta pregunta también.
   Si ves la declaración para el método java.util.Collections.addAll() obtendrás algo como esto:

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

   Por lo tanto, este código también es útil para hacerlo

   Collections.addAll(arraylist, array);

Answer 4

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

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

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 soportan muy bien 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 un ArrayList y no un 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 lo tanto, darán error cuando intenten 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 en la lista de representación de matriz de link .

Answer 5

Como esta pregunta es bastante antigua, me sorprende que nadie haya sugerido 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.

Answer 6

Dado:

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

La respuesta más simple es hacer:

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

Esto funcionará bien. Pero algunas advertencias:

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

Answer 7

Dado:

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

Utilizar:

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

Answer 8

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

Answer 9

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

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

Answer 10

En Java 9 puedes usar:

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

Answer 11

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

Answer 12

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

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

Se guardarán algunos caracteres, si esto pudiera ser solo una List

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

Answer 13

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

Collections.addAll(arraylist, array);

Answer 14

Otra forma sencilla es agregar todos los elementos de la matriz a una nueva ArrayList usando un bucle para cada uno.

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

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

Answer 15

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

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

Answer 16

Probablemente solo necesite una lista, no una lista de arreglos. En ese caso solo puedes hacer:

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

Answer 17

Puede hacerlo fácilmente con la ayuda de Arrays.asList (arrayObj);

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

Answer 18

Puedes hacerlo en java 8 de la siguiente manera

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

Answer 19

Se puede convertir utilizando 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

Answer 20

Si la matriz es de un 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());

Answer 21

Si utiliza :

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

¡Puedes crear y llenar dos listas! Lo que no desea hacer es rellenar dos veces una lista grande, ya que creará otra matriz Object[] cada vez que deba ampliarse 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 del objeto [] 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 cambias la matriz inicial, ¡cambias la Lista! ¿Estás seguro de que quieres eso? Tal vez si tal vez no.

Si no, 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 , Arrays o guayabas. Pero si no encaja, o si no lo siente, simplemente escriba otra línea poco elegante.

Answer 22

También puedes hacerlo con stream en Java 8.

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

Answer 23

Ya todos han proporcionado suficiente buena respuesta para su problema. Ahora de todas las sugerencias, debe decidir cuál se ajustará a sus necesidades. Hay dos tipos de colección que necesitas saber. Una es una colección no modificada y otra colección que le permitirá modificar el objeto más adelante.

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

Answer 24

como todos dijeron esto lo hará

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

y la forma más reciente de crear una matriz es observableArrays

ObservableList: una lista que permite a los oyentes realizar un seguimiento de los cambios cuando se producen.

para Java SE puedes probar

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

Eso es de acuerdo con Oracle Docs

observableArrayList () Crea una nueva lista observable vacía que está respaldada por un arraylist. observableArrayList (E ... items) Crea una nueva lista de matriz observable con elementos agregados a ella.

Actualizar Java 9

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

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

Answer 25

^{(hilo antiguo, pero solo 2 centavos porque ninguno menciona guava u otras libretas y algunos otros detalles)}

Si puedes, usa guayaba

Vale la pena señalar la forma de la Guayaba, que simplifica enormemente estos chanchullos:

Uso

Para una lista inmutable

Use la clase copyOf() y copyOf() métodos de fábrica of() y copyOf() ^{(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

Utilice la clase Lists y sus métodos de fábrica newArrayList() :

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, ya que el uso de los métodos de fábrica de guayaba permite inferir los tipos la mayor parte del tiempo. Sin embargo, este argumento contiene menos agua desde que Java 7 llegó con el nuevo operador de diamante.

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

Si no puedes ...

Para una lista inmutable

Utilice la clase Arrays de JDK y su método de fábrica asList() , envuelto con 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 usa una implementación concreta de ArrayList , pero NO es java.util.ArrayList . Es un tipo interno, que emula una ArrayList pero en realidad hace referencia directa a la matriz pasada y la hace "escritura completa" (las modificaciones se reflejan en la matriz).

Prohíbe las modificaciones a través de algunos de los métodos de la API de la List simplemente extendiendo una AbstractList (por lo tanto, no se admite la adición o eliminación de elementos), sin embargo, permite que las llamadas a set() anulen los elementos. Por lo tanto, esta lista no es realmente inmutable y una llamada a asList() debe envolverse con Collections.unmodifiableList() .

Vea el siguiente paso si necesita una lista mutable.

Para una lista mutable

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

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+

Para fines educativos: El buen camino 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);
}

Answer 26

Para convertir una matriz en un ArrayList, los desarrolladores a menudo hacen esto:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() devolverá una ArrayList que es una private static class inside Arrays , no es la clase java.util.ArrayList. The java.util.Arrays.ArrayList clase The java.util.Arrays.ArrayList tiene métodos set(), get(), contains() , pero no tiene ningún método para agregar elementos, por lo que su tamaño es fijo. Para crear un ArrayList real, debes hacer:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

El constructor de ArrayList puede aceptar un tipo de colección , que también es un súper tipo para java.util.Arrays.ArrayList

Answer 27

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

Answer 28

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

Answer 29

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

Answer 30

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

Asegúrese de que myArray sea ​​del mismo tipo que T Obtendrá un error de compilación si intenta crear una List<Integer> partir de una matriz de int , por ejemplo.