【问题标题】：How to convert an ArrayList containing Integers to primitive int array?如何将包含整数的 ArrayList 转换为原始 int 数组？
【发布时间】：2010-10-17 15:23:53
【问题描述】：

我正在尝试使用以下代码将包含 Integer 对象的 ArrayList 转换为原始 int[]，但它会引发编译时错误。可以用Java转换吗？

List<Integer> x =  new ArrayList<Integer>();
int[] n = (int[])x.toArray(int[x.size()]);

【问题讨论】：

不是那个问题的完全重复（虽然也不是很远）
是的，这是一个ArrayList，“duplicate”是一个普通的数组。
如果不需要原始整数，可以使用：List<Integer> x = new ArrayList<Integer>();Integer[] n = x.toArray(new Integer[0]);
Converting an array of objects to an array of their primitive types的可能重复
@cellepo 这个问题是关于对象和原始数组之间的转换，这是关于 ArrayList 和原始数组之间的转换

标签： java arrays arraylist primitive-types

【解决方案1】：

Java 8

int[] array = list.stream().mapToInt(i->i).toArray();

OR 

int[] array = list.stream().mapToInt(Integer::intValue).toArray();

【讨论】：

您的答案与this one 重复。请删除您的帖子，并尽量避免以后这样做。

【解决方案2】：

Arrays.setAll() 适用于大多数场景：

整数列表到原始 int 数组：

public static int[] convert(final List<Integer> list)
{
   final int[] out = new int[list.size()];
   Arrays.setAll(out, list::get);
   return out;
}

整数列表（由字符串组成）到原始 int 数组：

public static int[] convert(final List<String> list)
{
   final int[] out = new int[list.size()];
   Arrays.setAll(out, i -> Integer.parseInt(list.get(i)));
   return out;
}

整数数组到原始整数数组：

public static int[] convert(final Integer[] array)
{
   final int[] out = new int[array.length];
   Arrays.setAll(out, i -> array[i]);
   return out;
}

原始 int 数组到 Integer 数组：

public static Integer[] convert(final int[] array)
{
   final Integer[] out = new Integer[array.length];
   Arrays.setAll(out, i -> array[i]);
   return out;
}

【讨论】：

【解决方案3】：

接下来的行你可以找到从 int[] -> List -> int[] 的转换

   private static int[] convert(int[] arr) {
        List<Integer> myList=new ArrayList<Integer>();
        for(int number:arr){
               myList.add(number);
            }
        }
        int[] myArray=new int[myList.size()];
        for(int i=0;i<myList.size();i++){
           myArray[i]=myList.get(i);
        }
        return myArray;
    }

【讨论】：

【解决方案4】：

Java 8：

int[] intArr = Arrays.stream(integerList).mapToInt(i->i).toArray();

【讨论】：

【解决方案5】：

这对我很有效:)

发现于https://www.techiedelight.com/convert-list-integer-array-int/

import java.util.Arrays;
import java.util.List;

class ListUtil
{
    // Program to convert list of integer to array of int in Java
    public static void main(String args[])
    {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        int[] primitive = list.stream()
                            .mapToInt(Integer::intValue)
                            .toArray();

        System.out.println(Arrays.toString(primitive));
    }
}

【讨论】：

【解决方案6】：

一个非常简单的单行解决方案是：

Integer[] i = arrlist.stream().toArray(Integer[]::new);

【讨论】：

op 表示原始数组，意思是 int[] 而不是 Integer[] 包装对象，哈哈

【解决方案7】：

Arrays.setAll()

    List<Integer> x = new ArrayList<>(Arrays.asList(7, 9, 13));
    int[] n = new int[x.size()];
    Arrays.setAll(n, x::get);

    System.out.println("Array of primitive ints: " + Arrays.toString(n));

输出：

原始整数数组：[7, 9, 13]

同样适用于long 或double 的数组，但不适用于boolean、char、byte、short 或float 的数组。如果您的列表非常庞大，甚至可以使用 parallelSetAll 方法来代替。

对我来说，这已经足够好和优雅了，以至于我不想获取外部库也不想使用流。

文档链接： Arrays.setAll(int[], IntUnaryOperator)

【讨论】：

【解决方案8】：

这个代码段对我有用，试试这个：

Integer[] arr = x.toArray(new Integer[x.size()]);

值得一提的是 ArrayList 应该这样声明：

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

【讨论】：

您好，只是一个温和的提醒，OP 想要一个原始数组而不是对象数组。
原始整数不是包装整数！

【解决方案9】：

如果您使用Eclipse Collections，您可以使用collectInt() 方法从对象容器切换到原始int 容器。

List<Integer> integers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
MutableIntList intList =
  ListAdapter.adapt(integers).collectInt(i -> i);
Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intList.toArray());

如果您可以将ArrayList 转换为FastList，则可以摆脱适配器。

Assert.assertArrayEquals(
  new int[]{1, 2, 3, 4, 5},
  Lists.mutable.with(1, 2, 3, 4, 5)
    .collectInt(i -> i).toArray());

注意：我是 Eclipse 集合的提交者。

【讨论】：

【解决方案10】：

如果您使用的是java-8，还有另一种方法可以做到这一点。

int[] arr = list.stream().mapToInt(i -> i).toArray();

它的作用是：

从列表中获取Stream<Integer>
通过将每个元素映射到自身（身份函数）来获取IntStream，将每个Integer 对象持有的int 值拆箱（自Java 5 起自动完成）
通过调用toArray获取int的数组

您也可以通过方法引用显式调用intValue，即：

int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

还值得一提的是，如果您在列表中有任何null 参考，您可以获得NullPointerException。这可以通过向流管道添加过滤条件来轻松避免，如下所示：

                       //.filter(Objects::nonNull) also works
int[] arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray();

例子：

List<Integer> list = Arrays.asList(1, 2, 3, 4);
int[] arr = list.stream().mapToInt(i -> i).toArray(); //[1, 2, 3, 4]

list.set(1, null); //[1, null, 3, 4]
arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray(); //[1, 3, 4]

【讨论】：

我看到这可以用于double 类型； float 类型没有等价物吗？
通过您的详细解释看到了 Java 8 的好处。
这就是为什么 Java 8+ Stream API 很漂亮。

【解决方案11】：

谷歌番石榴

Google Guava 通过调用Ints.toArray 提供了一种简洁的方法来执行此操作。

List<Integer> list = ...;
int[] values = Ints.toArray(list);

【讨论】：

我认为这将是我的答案 - 我将在任何一天使用一个库而不是复制粘贴功能......尤其是一个体面大小的项目可能已经使用的库。我希望这个答案在未来得到更多的支持和知名度。
如何调用“Ints”？？？

【解决方案12】：

你可以简单地将它复制到一个数组中：

int[] arr = new int[list.size()];
for(int i = 0; i < list.size(); i++) {
    arr[i] = list.get(i);
}

不太花哨；但是，嘿，它有效...

【讨论】：

【解决方案13】：

我相信使用 List 的迭代器进行迭代是一个更好的主意，因为 list.get(i) 的性能可能会因 List 实现而变差：

private int[] buildIntArray(List<Integer> integers) {
    int[] ints = new int[integers.size()];
    int i = 0;
    for (Integer n : integers) {
        ints[i++] = n;
    }
    return ints;
}

【讨论】：

【解决方案14】：

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

    list.add(1);
    list.add(2);

    int[] result = null;
    StringBuffer strBuffer = new StringBuffer();
    for (Object o : list) {
        strBuffer.append(o);
        result = new int[] { Integer.parseInt(strBuffer.toString()) };
        for (Integer i : result) {
            System.out.println(i);
        }
        strBuffer.delete(0, strBuffer.length());
    }

【讨论】：

这个答案不起作用，它返回一个包含单个元素而不是多个元素的数组。
为什么要使用 StringBuffer？为什么将 Integer 转换为 String，然后转换为 Integer，然后转换为 int，然后再转换为 Integer？为什么要使用其中包含单个元素的数组，以及为什么在该单元素数组仅包含一个元素时循环该数组？为什么在外循环中将整数转换为对象？这里有很多问题。 @CodeMadness 只是一个巨魔帐户吗？

【解决方案15】：

让我感到困惑的是，只要像 Apache Commons 这样非常好的、使用良好的库已经解决了这个问题，我们就鼓励一次性自定义方法。尽管该解决方案即使不是荒谬也是微不足道的，但由于长期维护和可访问性而鼓励这种行为是不负责任的。

请使用Apache Commons

【讨论】：

我同意之前的评论。您不仅要拖入 Apache Commons，而且它很容易转换成大量的传递依赖项，这些依赖项也需要被拖入。最近我可以通过替换一行代码来删除一个惊人的依赖项 :-( 依赖项是昂贵的并且编写这样的基本代码是一个好习惯
同意@PeterKriens。如果有的话，Java 的错误在于其标准数据类型不支持像这样的简单转换

【解决方案16】：

你可以转换，但我认为没有内置的东西可以自动转换：

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    for (int i=0; i < ret.length; i++)
    {
        ret[i] = integers.get(i).intValue();
    }
    return ret;
}

（请注意，如果 integers 或其中的任何元素是 null，这将引发 NullPointerException。）

编辑：根据 cmets，您可能希望使用列表迭代器来避免诸如 LinkedList 之类的列表的讨厌成本：

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    Iterator<Integer> iterator = integers.iterator();
    for (int i = 0; i < ret.length; i++)
    {
        ret[i] = iterator.next().intValue();
    }
    return ret;
}

【讨论】：

最好使用 List 的迭代器（with for each）进行迭代，以避免对访问不是 O(1) 的列表造成性能影响。
您还可以利用 ArrayList 实现 Iterable 的事实（通过 Collection 继承）并执行以下操作： for(int n : integer) { ret[counter++] = n; } ... 并初始化 int counter = 0;
现在在 Java8 中容易多了：integers.stream().mapToInt(Integer::valueOf).toArray

【解决方案17】：

Integer[] arr = (Integer[]) x.toArray(new Integer[x.size()]);

像普通的int[]一样访问arr。

【讨论】：

这没有回答问题，问题是关于转换为原始类型（int）

【解决方案18】：

使用Dollar 应该很简单：

List<Integer> list = $(5).toList(); // the list 0, 1, 2, 3, 4  
int[] array = $($(list).toArray()).toIntArray();

我计划改进 DSL 以删除中间的 toArray() 调用

【讨论】：

【解决方案19】：

Apache Commons 有一个 ArrayUtils 类，它有一个方法 toPrimitive() 可以做到这一点。

import org.apache.commons.lang.ArrayUtils;
...
    List<Integer> list = new ArrayList<Integer>();
    list.add(new Integer(1));
    list.add(new Integer(2));
    int[] intArray = ArrayUtils.toPrimitive(list.toArray(new Integer[0]));

但是，正如 Jon 所展示的，您可以很容易地自行完成此操作，而不是使用外部库。

【讨论】：

请注意，这种方法将制作序列的两个完整副本：一个由 toArray 创建的 Integer[] 和一个在 toPrimitive 内部创建的 int[]。 Jon 的另一个答案只创建和填充一个数组。如果您的列表很大并且性能很重要，则需要考虑一些事项。
我使用 ArrayUtils 与纯 java 比较性能，并且在小列表（ --> int[])
@paraquat & Oskar Lund 实际上并不正确。是的，提供的代码将创建两个数组，但此方法不会。此代码中的问题是使用零长度数组作为参数。 ArrayList.toArray source code 表明如果内容适合，将使用原始数组。我认为在公平的比较中，您会发现这种方法同样有效（如果不是更高的话），当然，需要维护的代码更少。
PS：a nice related post
new Integer[0]的目的是什么？