如何将包含整数的ArrayList转换为原始int数组?


297

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

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

10
不是该问题的精确副本(尽管也不是很远)
Jonik

1
是的,这是一个ArrayList,“重复”是关于普通阵列的。
Scott McIntyre

3
如果不需要原始整数,则可以使用: List<Integer> x = new ArrayList<Integer>(); Integer[] n = x.toArray(new Integer[0]);
Evorlor 2015年

Answers:


219

您可以进行转换,但是我认为没有内置的功能可以自动进行转换:

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或任何一个元素为,则会抛出NullPointerException null。)

编辑:根据评论,您可能希望使用列表迭代器来避免诸如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;
}

21
最好使用List的迭代器(每个都有)进行迭代,以避免访问不为O(1)的列表的性能受到影响。
马修·威利斯,

@Matthew:是的,可能-将进行编辑以替代。
乔恩·斯基特

1
您还可以利用ArrayList实现Iterable的事实(通过Collection继承)并执行以下操作:for(int n:integer){ret [counter ++] = n; } ...并初始化int counter = 0;
gardarh 2014年

8
Java8现在要容易得多:integers.stream().mapToInt(Integer::valueOf).toArray
Manish Patel

241

如果您正在使用 还有另一种方法可以做到这一点。

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

它的作用是:

  • Stream<Integer>从列表中获取
  • IntStream通过将每个元素映射到自身来获得一个(身份函数),将int每个Integer对象保存的值拆箱(自Java 5起自动完成)
  • int通过调用获取数组toArray

您也可以intValue通过方法引用显式调用,即:

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

还值得一提的是,NullPointerException如果null列表中有任何引用,您都可以获取。可以通过向流管道中添加如下过滤条件来轻松避免这种情况:

                       //.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类型吗?
code_dredd

您的详尽解释看到了Java 8的好处。
尤金(Eugene)

这就是Java 8+ Stream API非常漂亮的原因。
Pranav A.

67

谷歌番石榴

Google Guava提供了一种巧妙的方法,可以通过调用Ints.toArray

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

6
我认为这将是我的答案-每天我都会在复制粘贴功能上使用一个库。尤其是一个相当大的项目可能已经使用的库。我希望这个答案在将来会得到更多的支持和知名度。
肖恩·康诺利

61

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所展示的,您可以很容易地自己完成此操作,而不是使用外部库。


2
请注意,此方法将完成序列的两个完整副本:一个由toArray创建的Integer [],以及一个在toPrimitive内部创建的int []。Jon的另一个答案仅创建并填充一个数组。如果列表很大,则需要考虑的因素是性能,这一点很重要。
百草枯

我使用ArrayUtils与纯Java进行了比较,在较小的列表(<25个元素)上,纯Java的性能提高了100倍以上。对于3k元素,纯Java仍然快将近2倍...(ArrayList <Integer>-> int [])
Oskar Lund

@paraquat和Oskar Lund实际上并不正确。是的,提供的代码将创建两个数组,但是这种方法不会。这段代码中的问题是使用零长度数组作为参数。的ArrayList.toArray源代码显示,如果内容将适合,原来的阵列将被使用。我认为,通过公平的比较,您会发现此方法效率很高(如果不是更高的话),当然,维护的代码也更少。
肖恩·康诺利


1
新Integer [0]的目的是什么?
亚当·休斯

41

我相信使用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;
}

6

使用Dollar应该很简单:

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

我正计划改善DSL以删除中间toArray()呼叫


1
嘿,只是想说我以前没看过Dollar,但我肯定会在下一个项目中尝试一下。那是一个不错的小api,请继续努力:)
Bart Vandendriessche

4

这对我来说很好:)

可在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));
    }
}

3

令我感到困惑的是,每当一个很好的,使用良好的库(如Apache Commons)已经解决了问题时,我们就鼓励一次性的自定义方法。尽管该解决方案即使不是荒谬的,也是微不足道的,但由于长期的维护和可访问性,鼓励这种行为是不负责任的。

只需使用Apache Commons


7
我同意以前的评论者。您不仅可以拖入Apache Commons,而且还可以轻松地转换为大量需要传递的可传递依赖项。最近,我可以通过替换一行代码来消除令人惊讶的依赖项数量:-(依赖项成本高昂,像这样编写基本代码是一种好习惯
Peter Kriens 2010年

1
同意@PeterKriens。如果有的话,Java的错误在于它在标准数据类型中不支持像这样的简单转换
Adam Hughes

3

如果使用的是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());

如果可以将转换ArrayListFastList,则可以摆脱适配器。

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

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


3

Java 8:

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

2

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]

对的阵列相同的作品longdouble,但不适合的阵列booleancharbyteshortfloat。如果您的清单很大,甚至parallelSetAll可以使用一种方法代替。

对我来说,这很好,而且很优雅,以至于我不想获得一个外部库也不使用流。

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


1

您可以简单地将其复制到数组中:

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

不太花哨;但是,嘿,它有效...


1

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

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

0

此代码段为我工作,请尝试以下操作:

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

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

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

5
您好,只是提醒您,OP需要原始数组而不是Object数组。
OLIVER.KOO

3
原始int不能包装Integer!
Bartzilla

-4
   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());
    }

1
该答案不起作用,它返回一个包含单个元素而不是多个元素的数组。
Mysticial

为什么要使用StringBuffer?为什么将Integer转换为String,然后转换为Integer,然后转换为int,然后再次转换为Integer?为什么要使用其中包含单个元素的数组,为什么要在仅包含一个元素的那个单元素数组上循环呢?为什么在外部循环中将整数转换为对象?这里有很多问题。@CodeMadness只是一个巨魔帐户吗?
维克多·扎曼尼安

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

arr正常访问int[]


5
这没有回答问题,问题是关于转换为原始类型(int)
Asaf 2012年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.