java - arrays aslist integer

Convierta una matriz de longs primitivos en una lista de Longs

Question

Esto puede ser un poco fácil, tipo de pregunta, pero mi primer intento, sorprendentemente, no funcionó por completo. Quería tomar una serie de largos primitivos y convertirlos en una lista, que intenté hacer así:

long[] input = someAPI.getSomeLongs();
List<Long> inputAsList = Arrays.asList(input); //Total failure to even compile!

¿Cuál es la forma correcta de hacer esto?

Answer 1

Combinando las respuestas de Pavel y Tom obtenemos esto

   @SuppressWarnings("unchecked")
    public static <T> List<T> asList(final Object array) {
        if (!array.getClass().isArray())
            throw new IllegalArgumentException("Not an array");
        return new AbstractList<T>() {
            @Override
            public T get(int index) {
                return (T) Array.get(array, index);
            }

            @Override
            public int size() {
                return Array.getLength(array);
            }
        };
    }

Answer 2

Como otra posibilidad, la biblioteca de Guava proporciona esto como Longs.asList() , con clases de utilidad similares para los otros tipos primitivos.

import com.google.common.primitives.Longs;

long[] input = someAPI.getSomeLongs();
List<Long> output = Longs.asList(input);

Answer 3

Desde Java 8 ahora puedes usar streams para eso:

long[] arr = {1,2,3,4};
List<Long> list = Arrays.stream(arr).boxed().collect(Collectors.toList());

Answer 4

Estoy escribiendo una pequeña biblioteca para estos problemas:

long[] input = someAPI.getSomeLongs();
List<Long> = $(input).toList();

En el caso que te interese, verifícalo here .

Answer 5

Me pareció conveniente usar apache commons lang ArrayUtils (JavaDoc)

long[] input = someAPI.getSomeLongs();
Long[] inputBoxed = ArrayUtils.toObject(input);
List<Long> inputAsList = Arrays.asList(inputBoxed);

también tiene la API inversa

long[] backToPrimitive = ArrayUtils.toPrimitive(objectArray);

EDITAR: actualizado para proporcionar una conversión completa a una lista según lo sugerido por los comentarios y otras soluciones.

Answer 6

No, no hay conversión automática de una matriz de tipo primitivo a una matriz de sus tipos de referencia encuadrados. Solo puedes hacer

long[] input = someAPI.getSomeLongs();
List<Long> lst = new ArrayList<Long>();

for(long l : input) lst.add(l);

Answer 7

Otra forma con Java 8.

long[] input = someAPI.getSomeLongs();
LongStream.of(input).boxed().collect(Collectors.toList()));

Answer 8

Otra way con Java 8.

final long[] a = new long[]{1L, 2L};
final List<Long> l = Arrays.stream(a).boxed().collect(Collectors.toList());

Answer 9

Puedes usar transmorph :

Transmorph transmorph = new Transmorph(new DefaultConverters());
List<Long> = transmorph.convert(new long[] {1,2,3,4}, new TypeReference<List<Long>>() {});

También funciona si source es una matriz de ints, por ejemplo.

Answer 10

Sé que esta pregunta es lo suficientemente antigua, pero ... también puedes escribir tu propio método de conversión:

@SuppressWarnings("unchecked")
public static <T> List<T> toList(Object... items) {

    List<T> list = new ArrayList<T>();

    if (items.length == 1 && items[0].getClass().isArray()) {
        int length = Array.getLength(items[0]);
        for (int i = 0; i < length; i++) {
            Object element = Array.get(items[0], i);
            T item = (T)element;
            list.add(item);
        }
    } else {
        for (Object i : items) {
            T item = (T)i;
            list.add(item);
        }
    }

    return list;
}

Después de incluirlo usando importación estática, los posibles usos podrían ser:

    long[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    List<Long> list = toList(array);

o

    List<Long> list = toList(1l, 2l, 3l, 4l, 5l, 6l, 7l, 8l, 9l);

Answer 11

Si desea una semántica similar a Arrays.asList , deberá escribir (o usar la Arrays.asList otra persona) la implementación de List (probablemente a través de AbstractList . Debe tener la misma implementación que Arrays.asList , solo los valores de cuadro y unbox.

Answer 12

Un poco más detallado, pero esto funciona:

    List<Long> list = new ArrayList<Long>();
    for (long value : input) {
        list.add(value);
    }

En su ejemplo, parece que Arrays.asList () interpreta la entrada como una lista de matrices largas [] en lugar de una lista de Longs. Un poco sorprendente, seguro. El autoboxing simplemente no funciona de la manera que usted desea en este caso.

Answer 13

hallidave y jpalecek tienen la idea correcta: iterar sobre una matriz, pero no aprovechan una característica proporcionada por ArrayList : dado que en este caso se conoce el tamaño de la lista , debe especificarla al crear ArrayList .

List<Long> list = new ArrayList<Long>(input.length);
for (long n : input)
  list.add(n);

De esta forma, no se crean matrices innecesarias para que la ArrayList las descarte porque son demasiado cortas, y no se desperdician "ranuras" vacías porque ArrayList sobrestimó sus requisitos de espacio. Por supuesto, si continúa agregando elementos a la lista, se necesitará una nueva matriz de respaldo.

Answer 14

import java.util.Arrays;
import org.apache.commons.lang.ArrayUtils;

List<Long> longs = Arrays.asList(ArrayUtils.toObject(new long[] {1,2,3,4}));