web-dev-qa-db-fra.com

Un moyen efficace de convertir List <Integer> en int [] (tableau) sans itération

  public static int[] convertListToArray(List<Integer> listResult) {
        int[] result = new int[listResult.size()];
        int i= 0;
        for (int num : listResult) {
            result[i++] = num;
        }
        return result;
    }

Existe-t-il un moyen efficace de convertir List en tableau sans itérer List explicitement? C'est peut-être possible en utilisant des méthodes comme:

Arrays.copyOf(int [] Origin , int newLength );
System.arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

Je sais qu'il existe une solution décrite ici . Cependant, je suis particulièrement intéressé par un moyen efficace de convertir List<Integer> à int[]

javaarrayslist
14
Tim Florian

Étant donné la nécessité de convertir de Integer en int, je ne pense pas que vous allez trouver quelque chose de plus efficace que ce que vous avez, si je suppose que vous parlez d'efficacité d'exécution.

Vous pourriez trouver la conversion en Integer[] en premier puis en boucle pourrait être plus efficace (ci-dessous), mais vous pourriez aussi pas, aussi. Vous devez le tester dans votre scénario spécifique et voir.

Voici cet exemple:

int size = listResult.size();
int[] result = new int[size];
Integer[] temp = listResult.toArray(new Integer[size]);
for (int n = 0; n < size; ++n) {
    result[n] = temp[n];
}
9
T.J. Crowder

Si l'efficacité est votre principale préoccupation, je pense que vous pouvez utiliser votre solution et la rendre plus efficace en utilisant une boucle indexée pour sur listResult si elle est RandomAccess . Cependant, cela rend le code beaucoup moins lisible, et vous devrez le comparer à vos cas d'utilisation pour voir s'il est plus efficace.

public static int[] convertListToArray(List<Integer> listResult) {
    int size = listResult.size();
    int[] result = new int[size];
    if (listResult instanceof RandomAccess)
    {
        for (int i = 0; i < size; i++)
        {
            result[i] = listResult.get(i);
        }
    }
    else
    {
        int i = 0;
        for (int num : listResult) {
            result[i++] = num;
        }
    }
    return result;
}

Si vous utilisez Java 8 et souhaitez écrire moins de code, vous pouvez utiliser la bibliothèque Streams.

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

Si vous êtes prêt à utiliser une bibliothèque tierce, vous pouvez Collections Eclipse comme suit.

MutableList<Integer> list = Lists.mutable.with(1, 2, 3, 4, 5);
int[] array = list.collectInt(i -> i).toArray();

Ce qui suit est un peu plus de code, mais c'est la solution la plus efficace que j'ai pu trouver avec les collections Eclipse.

MutableList<Integer> list = Lists.mutable.with(1, 2, 3, 4, 5);
int[] array = new int[list.size()];
list.forEachWithIndex((each, index) -> array[index] = each);

Si vous devez utiliser le Java.util.List interface, la classe d'utilitaire ListIterate peut être utilisée à partir des collections Eclipse.

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int[] array = new int[list.size()];
ListIterate.forEachWithIndex(list, (each, index) -> array[index] = each);

L'utilitaire ListIterate utilisera un code d'itération différent pour les listes RandomAccess et les listes nonRandomAccess.

La chose la plus efficace à faire serait de changer le List<Integer> à MutableIntList dans les collections Eclipse ou une autre bibliothèque prenant en charge les collections primitives.

Remarque: je suis un committer pour les collections Eclipse.

11
Donald Raab

Dans Java 8:

int[] anArray = list.stream()
                    .filter(Objects::nonNull)
                    .mapToInt(Integer::intValue)
                    .toArray();
4
Saxintosh