如何在 Java 中将 int[] 转换为 List<Integer>？

Posted 2023-02-25

【中文标题】如何在 Java 中将 int[] 转换为 List<Integer>？

【英文标题】：How to convert int[] into List<Integer> in Java?

【发布时间】：2010-11-07 14:49:55

【问题描述】：

如何在 Java 中将int[] 转换为List<Integer>？

当然，除了逐项循环执行之外，我对任何其他答案都感兴趣。但如果没有其他答案，我会选择一个作为最好的答案，以表明此功能不是 Java 的一部分。

【问题讨论】：

我们可以利用 IntStream.Of(array).collect(Collectors.toList)

@SarojKumarSahoo collect 在IntStream 中没有唯一的参数。

没有build-in 方法可以做到这一点。您必须手动完成，声明一个 ArrayList 并将 int Array 中的每个值添加到 ArrayList。多么想念！

【参考方案1】：

流

在 Java 8+ 中，您可以创建 int 数组的流。致电Arrays.stream 或IntStream.of。 调用IntStream#boxed 以使用从int 原语到Integer 对象的装箱转换。 使用Stream.collect( Collectors.toList() ) 收集到一个列表中。或者更简单地说，在 Java 16+ 中，调用 Stream#toList()。

例子：

int[] ints = 1,2,3;
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

在 Java 16 及更高版本中：

List<Integer> list = Arrays.stream(ints).boxed().toList();

【讨论】：

等价于：Arrays.stream(ints).boxed().collect(Collectors.toList());

@njfrost 你是对的，IntStream.of 只是调用 Arrays.stream 所以我根据你的建议改进了答案

由于某种原因，这似乎没有在 android Studio 上返回预期的结果类型（适用于 eclipse）它说，预期 List found List

它看起来简洁明了，但是当我使用它而不是 @willcodejavaforfood 在 leetcode 上提供的基本解决方案时，程序性能在内存和运行时方面都会下降

@chitreshsirohi 这是因为流中使用的 lambda 函数导致 Java 生成一些匿名类。

【参考方案2】：

没有将int[] 转换为List<Integer> 的捷径，因为Arrays.asList 不处理拳击，只会创建一个List<int[]>，这不是您想要的。你必须创建一个实用方法。

int[] ints = 1, 2, 3;
List<Integer> intList = new ArrayList<Integer>(ints.length);
for (int i : ints)

    intList.add(i);

【讨论】：

最好用数组的大小来初始化列表

for (int i : ints) intList.add(i);

@willcodejavaforfood - David 的意思是这样更好：new ArrayList(ints.length);

@willcodejavaforfood：在构造 ArrayList 时声明它的大小将防止它在添加一定数量后必须在内部调整大小。不确定好处是否很小，但肯定有好处。

new ArrayList<Integer>() for (int i : ints) add(i);

【参考方案3】：

同样来自guava libraries... com.google.common.primitives.Ints：

List<Integer> Ints.asList(int...)

【讨论】：

这个应该是正确的答案。请参阅问题的第二句：“当然，我对任何其他答案感兴趣，而不是逐项循环执行。”

这里有一些微妙之处。返回的列表使用提供的数组作为后备存储，因此您不应更改数组。该列表也不保证包含的 Integer 对象的身份。即没有指定list.get(0) == list.get(0)的结果。

在添加库时要注意 Android 上的方法引用计数。不过很好找。

【参考方案4】：

Arrays.asList 不会像其他一些答案所期望的那样工作。

此代码将不创建一个包含 10 个整数的列表。它将打印 1，而不是 10：

int arr[] =  1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ;
List lst = Arrays.asList(arr);
System.out.println(lst.size());

这将创建一个整数列表：

List<Integer> lst = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

如果您已经拥有整数数组，则没有快速转换的方法，您最好使用循环。

另一方面，如果您的数组中包含对象，而不是原语，则 Arrays.asList 将起作用：

String str[] =  "Homer", "Marge", "Bart", "Lisa", "Maggie" ;
List<String> lst = Arrays.asList(str);

【讨论】：

请注意，该列表是不可变的

上述注释中的

Arrays.asList(arr) 将生成与 List 不兼容的 List 类型的列表。如果要尝试将输出分配给像这样的变量 ``` List l = Arrays.asList(arr); ``` 你会得到以下错误 |错误：|不兼容的类型：推理变量 T 具有不兼容的界限 |等式约束：java.lang.Integer |下界：int[] |列表 l = Arrays.asList(a); | ^--------------^

【参考方案5】：

我会用不同的方法添加另一个答案；没有循环，而是一个将利用自动装箱功能的匿名类：

public List<Integer> asList(final int[] is)

    return new AbstractList<Integer>() 
            public Integer get(int i)  return is[i]; 
            public int size()  return is.length; 
    ;

【讨论】：

+1 这比我的短，但我的适用于所有基元类型

虽然比创建 ArrayList 更快且使用更少的内存，但要权衡的是 List.add() 和 List.remove() 不起作用。

对于具有稀疏访问模式的大型数组，我非常喜欢这种解决方案，但对于频繁访问的元素，它会导致许多不必要的 Integer 实例化（例如，如果您访问同一个元素 100 次）。您还需要定义迭代器并将返回值包装在 Collections.unmodifiableList 中。

@Christoffer 谢谢。我已经添加了set 方法，现在我什至可以对数组进行排序...

【参考方案6】：

最小的一段代码是：

public List<Integer> myWork(int[] array) 
    return Arrays.asList(ArrayUtils.toObject(array));

ArrayUtils 来自 commons-lang :)

【讨论】：

请注意 ArrayUtils 对于 Android 应用来说这是一个相对较大的库

这里描述的是相反的操作：***.com/a/960507/1333157ArrayUtils.toPrimitive(...)是关键。

【参考方案7】：

在带有流的 Java 8 中：

int[] ints = 1, 2, 3;
List<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, Arrays.stream(ints).boxed().toArray(Integer[]::new));

或与收藏家一起

List<Integer> list =  Arrays.stream(ints).boxed().collect(Collectors.toList());

【讨论】：

为什么不简单地使用收集器？

【参考方案8】：

在 Java 8 中：

int[] arr = 1,2,3;
IntStream.of(arr).boxed().collect(Collectors.toList());

【参考方案9】：

如果您使用的是 java 8，我们可以使用流 API 将其转换为列表。

List<Integer> list = Arrays.stream(arr)     // IntStream 
                                .boxed()        // Stream<Integer>
                                .collect(Collectors.toList());

您也可以使用 IntStream 进行转换。

List<Integer> list = IntStream.of(arr) // return Intstream
                                    .boxed()        // Stream<Integer>
                                    .collect(Collectors.toList());

还有其他外部库，例如 guava 和 apache commons 也可以转换它。

干杯。

【参考方案10】：

还值得一试this bug report，它已关闭，原因是“不是缺陷”和以下文字：

“没有指定整个数组的自动装箱行为，这是有充分理由的。 对于大型阵列来说，它可能会非常昂贵。”

【参考方案11】：

试试这门课：

class PrimitiveWrapper<T> extends AbstractList<T> 

    private final T[] data;

    private PrimitiveWrapper(T[] data) 
        this.data = data; // you can clone this array for preventing aliasing
    

    public static <T> List<T> ofIntegers(int... data) 
        return new PrimitiveWrapper(toBoxedArray(Integer.class, data));
    

    public static <T> List<T> ofCharacters(char... data) 
        return new PrimitiveWrapper(toBoxedArray(Character.class, data));
    

    public static <T> List<T> ofDoubles(double... data) 
        return new PrimitiveWrapper(toBoxedArray(Double.class, data));
      

    // ditto for byte, float, boolean, long

    private static <T> T[] toBoxedArray(Class<T> boxClass, Object components) 
        final int length = Array.getLength(components);
        Object res = Array.newInstance(boxClass, length);

        for (int i = 0; i < length; i++) 
            Array.set(res, i, Array.get(components, i));
        

        return (T[]) res;
    

    @Override
    public T get(int index) 
        return data[index];
    

    @Override
    public int size() 
        return data.length;
    

测试用例：

List<Integer> ints = PrimitiveWrapper.ofIntegers(10, 20);
List<Double> doubles = PrimitiveWrapper.ofDoubles(10, 20);
// etc

【参考方案12】：

最佳镜头：

**
 * Integer modifiable fix length list of an int array or many int's.
 *
 * @author Daniel De Leon.
 */
public class IntegerListWrap extends AbstractList<Integer> 

    int[] data;

    public IntegerListWrap(int... data) 
        this.data = data;
    

    @Override
    public Integer get(int index) 
        return data[index];
    

    @Override
    public Integer set(int index, Integer element) 
        int r = data[index];
        data[index] = element;
        return r;
    

    @Override
    public int size() 
        return data.length;
    

支持获取和设置。 没有内存数据重复。 不会在循环中浪费时间。

例子：

int[] intArray = new int[]1, 2, 3;
List<Integer> integerListWrap = new IntegerListWrap(intArray);
List<Integer> integerListWrap1 = new IntegerListWrap(1, 2, 3);

【讨论】：

我最喜欢它。但我仍然会使用番石榴来获得直接的解决方案:)

【参考方案13】：

int[] arr =  1, 2, 3, 4, 5 ;

List<Integer> list = Arrays.stream(arr)     // IntStream
                            .boxed()        // Stream<Integer>
                            .collect(Collectors.toList());

见this

【参考方案14】：

这是另一种可能性，同样适用于 Java 8 Streams：

void intArrayToListOfIntegers(int[] arr, List<Integer> list) 
    IntStream.range(0, arr.length).forEach(i -> list.add(arr[i]));

【参考方案15】：

如果您愿意使用第三方库，这将在Eclipse Collections 中工作：

int[] a = 1, 2, 3;
List<Integer> integers = IntLists.mutable.with(a).collect(i -> i);
Assert.assertEquals(Lists.mutable.with(1, 2, 3), integers);

注意：我是Eclipse Collections 的提交者。

【参考方案16】：

   /* Integer[] to List<Integer> */



        Integer[] intArr =  10, 20, 30, 40, 50, 60, 70, 80, 90, 100 ;
        List<Integer> arrList = new ArrayList<>();
        arrList.addAll(Arrays.asList(intArr));
        System.out.println(arrList);


/* Integer[] to Collection<Integer> */


    Integer[] intArr =  10, 20, 30, 40, 50, 60, 70, 80, 90, 100 ;
    Collection<Integer> c = Arrays.asList(intArr);

【参考方案17】：

这个呢：

int[] a = 1,2,3; Integer[] b = ArrayUtils.toObject(a); List<Integer> c = Arrays.asList(b);

【参考方案18】：

这里有一个解决方案：

int[] array =  1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ;

Integer[] iArray = Arrays.stream(array).boxed().toArray(Integer[]::new);
System.out.println(Arrays.toString(iArray));

List<Integer> list = new ArrayList<>();
Collections.addAll(list, iArray);
System.out.println(list);

输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

【参考方案19】：

这是一种将数组转换为 ArrayList 的通用方法

<T> ArrayList<T> toArrayList(Object o, Class<T> type)
    ArrayList<T> objects = new ArrayList<>();
    for (int i = 0; i < Array.getLength(o); i++) 
        //noinspection unchecked
        objects.add((T) Array.get(o, i));
    
    return objects;

用法

ArrayList<Integer> list = toArrayList(new int[]1,2,3, Integer.class);

【参考方案20】：

Arrays.stream(ints).forEach(list::add);

【讨论】：

@TomerShetah 该声明是不言自明的。我希望读者对 Java Stream API 有一点了解。