将原始长整型数组转换为长整型列表

Question

这可能是一个有点简单的、办公桌式的问题，但令人惊讶的是，我的第一次尝试完全失败了。 我想获取一个原始长整型数组并将其转换为一个列表，我尝试这样做：

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

正确的方法是什么？

Answer 1

从 Java 8 开始，您现在可以使用流来实现：

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

Answer 2

我发现使用 apache commons lang ArrayUtils 很方便（JavaDoc, Maven 依赖项）

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

它还更新了反向 API

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

编辑：，以按照评论和其他修复的建议提供对列表的完整转换。

Answer 3

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

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

Answer 4

hallidave 和jpalecek 有正确的想法是迭代数组，但它们没有利用 ArrayList 提供的功能：因为在这种情况下列表的大小是已知的，因此您可以应在创建 ArrayList 时指定它。

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

这样，就不会创建不必要的数组，而只是因为它们太短而被 ArrayList 丢弃，并且不会因为 ArrayList 高估其值而浪费空“槽”。空间要求。 当然，如果继续向列表添加元素，则需要一个新的后备数组。

Answer 5

有点详细，但这有效：

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

在您的示例中， Arrays.asList() 似乎将输入解释为 long[] 数组列表，而不是 Long 列表。 确实有点令人惊讶。 在这种情况下，自动装箱并不能按照您希望的方式工作。

Answer 6

作为另一种可能性，Guava 库将其提供为 Longs.asList() ，对于其他基本类型具有类似的实用程序类。

import com.google.common.primitives.Longs;

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

Answer 7

^{问题询问如何将数组转换为列表。 到目前为止，大多数答案都展示了如何创建一个与数组内容相同的新列表，或引用第三方库。 但是，有一些简单的内置选项可用于此类转换。 其中一些已经在其他答案中概述（例如这个）。 但我想指出并详细说明此处实施的一定程度的自由度，并展示潜在的好处、缺点和注意事项。}

有两个重要的区别：

• 至少 数组上的视图，或者它是否应该是新列表
• 生成的列表是否应该可修改

这些选项将在此处快速总结，完整的示例程序显示在这个答案的底部。

---

创建新列表与在数组上创建视图

当结果应该是新列表时，则使用其他答案中的方法之一可以使用：

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

但应该考虑这样做的缺点：具有 1000000 个 long 值的数组将占用大约 8 MB 的内存。 新列表也将占用大约 8 MB。 当然，在创建此列表时必须遍历整个数组。 在许多情况下，创建新列表根本没有必要。 相反，在数组上创建一个视图就足够了：

// This occupies ca. 8 MB
long array[] = { /* 1 million elements */ }

// Properly implemented, this list will only occupy a few bytes,
// and the array does NOT have to be traversed, meaning that this
// operation has nearly ZERO memory- and processing overhead:
List<Long> list = asList(array);

^{（请参阅底部的示例以了解 toList 方法的实现）}

在数组上拥有视图意味着数组中的更改将在列表中可见：

long array[] = { 12, 34, 56, 78 };
List<Long> list = asList(array);

System.out.println(list.get(1)); // This will print 34

// Modify the array contents:
array[1] = 12345;

System.out.println(list.get(1)); // This will now print 12345!

幸运的是，创建一个副本（即，一个不存在的新列表）从视图来看，受数组中修改的影响是微不足道的：

List<Long> copy = new ArrayList<Long>(asList(array));

现在，这是一个真实的副本，相当于上面显示的基于流的解决方案所实现的效果。

---

创建可修改视图或不可修改视图

在许多情况下，列表只读就足够了>。 结果列表的内容通常不会被修改，而只会传递到仅读取列表的下游处理。

允许修改列表会引发一些问题：

long array[] = { 12, 34, 56, 78 };
List<Long> list = asList(array);

list.set(2, 34567);           // Should this be possible?
System.out.println(array[2]); // Should this print 34567?
list.set(3, null);            // What should happen here?
list.add(99999);              // Should this be possible?

可以在数组上创建可修改的列表视图。 这意味着列表中的更改（例如在某个索引处设置新值）将在数组中可见。

但不可能创建结构上可修改的列表视图。 这意味着不可能执行影响列表大小的操作。 这只是因为底层数组的大小无法更改。

---

以下是 MCVE，显示了不同的实现选项以及使用结果列表的可能方法：

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.RandomAccess;

public class PrimitiveArraysAsLists
{
    public static void main(String[] args)
    {
        long array[] = { 12, 34, 56, 78 };

        // Create VIEWS on the given array
        List<Long> list = asList(array);
        List<Long> unmodifiableList = asUnmodifiableList(array);

        // If a NEW list is desired (and not a VIEW on the array), this
        // can be created as well:
        List<Long> copy = new ArrayList<Long>(asList(array));

        System.out.println("array           : " + Arrays.toString(array));
        System.out.println("list            : " + list);
        System.out.println("unmodifiableList: " + unmodifiableList);
        System.out.println("copy            : " + copy);        

        // Modify a value in the array. The changes will be visible
        // in the list and the unmodifiable list, but not in
        // the copy.
        System.out.println("Changing value at index 1 of the array...");
        array[1] = 34567;

        System.out.println("array           : " + Arrays.toString(array));
        System.out.println("list            : " + list);
        System.out.println("unmodifiableList: " + unmodifiableList);
        System.out.println("copy            : " + copy);        

        // Modify a value of the list. The changes will be visible
        // in the array and the unmodifiable list, but not in
        // the copy.
        System.out.println("Changing value at index 2 of the list...");
        list.set(2, 56789L);

        System.out.println("array           : " + Arrays.toString(array));
        System.out.println("list            : " + list);
        System.out.println("unmodifiableList: " + unmodifiableList);
        System.out.println("copy            : " + copy);        


        // Certain operations are not supported:
        try
        {
            // Throws an UnsupportedOperationException: This list is 
            // unmodifiable, because the "set" method is not implemented
            unmodifiableList.set(2, 23456L);
        }
        catch (UnsupportedOperationException e) 
        {
            System.out.println("Expected: " + e);
        }

        try
        {
            // Throws an UnsupportedOperationException: The size of the
            // backing array cannot be changed
            list.add(90L);
        }
        catch (UnsupportedOperationException e) 
        {
            System.out.println("Expected: " + e);
        }


        try
        {
            // Throws a NullPointerException: The value 'null' cannot be  
            // converted to a primitive 'long' value for the underlying array
            list.set(2, null);
        }
        catch (NullPointerException e)
        {
            System.out.println("Expected: " + e);
        }

    }

    /**
     * Returns an unmodifiable view on the given array, as a list.
     * Changes in the given array will be visible in the returned
     * list.
     *  
     * @param array The array
     * @return The list view
     */
    private static List<Long> asUnmodifiableList(long array[])
    {
        Objects.requireNonNull(array);
        class ResultList extends AbstractList<Long> implements RandomAccess
        {
            @Override
            public Long get(int index)
            {
                return array[index];
            }

            @Override
            public int size()
            {
                return array.length;
            }
        };
        return new ResultList();
    }

    /**
     * Returns a view on the given array, as a list. Changes in the given 
     * array will be visible in the returned list, and vice versa. The
     * list does not allow for <i>structural modifications</i>, meaning
     * that it is not possible to change the size of the list.
     *  
     * @param array The array
     * @return The list view
     */
    private static List<Long> asList(long array[])
    {
        Objects.requireNonNull(array);
        class ResultList extends AbstractList<Long> implements RandomAccess
        {
            @Override
            public Long get(int index)
            {
                return array[index];
            }

            @Override
            public Long set(int index, Long element)
            {
                long old = array[index];
                array[index] = element;
                return old;
            }

            @Override
            public int size()
            {
                return array.length;
            }
        };
        return new ResultList();
    }

}

显示了示例的输出这里：

array           : [12, 34, 56, 78]
list            : [12, 34, 56, 78]
unmodifiableList: [12, 34, 56, 78]
copy            : [12, 34, 56, 78]
Changing value at index 1 of the array...
array           : [12, 34567, 56, 78]
list            : [12, 34567, 56, 78]
unmodifiableList: [12, 34567, 56, 78]
copy            : [12, 34, 56, 78]
Changing value at index 2 of the list...
array           : [12, 34567, 56789, 78]
list            : [12, 34567, 56789, 78]
unmodifiableList: [12, 34567, 56789, 78]
copy            : [12, 34, 56, 78]
Expected: java.lang.UnsupportedOperationException
Expected: java.lang.UnsupportedOperationException
Expected: java.lang.NullPointerException

Answer 8

不，没有从原始类型数组到装箱引用类型数组的自动转换。 你只能做

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

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

Answer 9

Java 8 的另一种方式。

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

Answer 10

我正在为这些问题编写一个小型库：

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

如果您关心的话，请检查此处。

Answer 11

Java 8 的另一种方式。

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

Answer 12

结合帕维尔和汤姆的答案我们得到这个

   @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 13

如果您想要与 Arrays.asList 类似的语义，那么您需要编写（或使用其他人的）List 的客户实现（可能通过 AbstractList > 它应该与 Arrays.asList 具有大致相同的实现，只是装箱和取消装箱值。

Answer 14

您可以使用 transmorph ：

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

例如，如果源是整数数组，它也可以工作。

Answer 15

我知道这个问题已经足够老了，但是...您也可以编写自己的转换方法：

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

使用静态导入包含它后，可能的用法可能是：

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

或

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

Answer 16

虽然可以创建一个新列表并向其中添加所有值（通过 for 循环或流），但我一直在处理非常大的数组，但性能很差。 因此，我创建了自己的易于使用的原始数组包装类。

示例：

long[] arr = new long[] {1,2,3};
PrimativeList<Long> list = PrimativeList.create(arr); // detects long[] and returns PrimativeList<Long>

System.out.println(list.get(1)); // prints: 2
list.set(2, 15);
System.out.println(arr[2]);  // prints: 15

在这里获取：
https://github.com/ Sf298/Sauds-Toolbox/blob/master/src/main/java/PrimitiveArrayWrapper/PrimitiveList.java

注意：我还没有完全测试它，所以如果您发现任何错误/问题，请告诉我。

Answer 17

您可以使用 LongStream 来实现

List<Long> longs = LongStream.of(new long[]{1L, 2L, 3L}).boxed()
                             .collect(Collectors.toList());