Question

我有：

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

我要转换为`

int[][] adjL = new int[?][?];

这可能吗？我应该用？

替换数组大小中的?

Answer 1

不简单，但这可以帮到你：

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

Integer[][] result = new Integer[adjList.size()][];//create your array of arrays
for (int i = 0; i < adjList.size(); i++) {
    //foreach array you have to inisialize it with the correct size
    result[i] = new Integer[adjList.get(i).size()];

    //the fill the array with the value of your list
    for(int j = 0; j < adjList.get(i).size(); j++){
        result[i][j] = adjList.get(i).get(j);
    }
}

对于这样的输入：

adjList.add(new ArrayList<>(Arrays.asList(1, 2, 3, 4)));
adjList.add(new ArrayList<>(Arrays.asList(1, 2, 3)));
...    
System.out.println(Arrays.deepToString(result));

输出：

[[1, 2, 3, 4], [1, 2, 3]]

Answer 2

虽然建议的解决方案返回Integer[][]而不是问题中要求的int[][]，但问题基本上得到了回答，但这可能是一个细节。

然而，将“数字集合”转换为2D原始数组的任务是非常通用的，因此，可以非常通用地编写。

所以这是另一个使用流的解决方案，可以应用于任意数字的任意集合。它可能不一定比其他解决方案“更好”，但可能作为其他应用案例的参考。

它显示了将ArrayList<ArrayList<Integer>>转换为int[][]数组的情况，但也包含方法showingThatThisIsFarMoreGeneric。

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.Vector;

public class ToIntArray2D
{
    public static void main(String[] args)
    {
        ArrayList<ArrayList<Integer>> adjList = createTestLists();
        int[][] result = toIntArray2D(adjList);
        System.out.println(Arrays.deepToString(result));
    }

    private static int[][] toIntArray2D(
        Collection<? extends Collection<? extends Number>> collections)
    {
        return collections.stream()
            .map(c -> toIntArray(c))
            .<int[]> toArray(int[][]::new);
    }

    private static int[] toIntArray(
        Collection<? extends Number> collection)
    {
        return collection.stream().mapToInt(Number::intValue).toArray();
    }

    private static void showingThatThisIsFarMoreGeneric()
    {
        ArrayList<ArrayList<Integer>> exampleA = null;
        List<List<Integer>> exampleB = null;
        Set<Vector<Float>> exampleC = null;
        LinkedList<HashSet<? extends BigInteger>> exampleD = null;
        LinkedList<? extends HashSet<? extends BigDecimal>> exampleE = null;

        toIntArray2D(exampleA); // Works
        toIntArray2D(exampleB); // Works
        toIntArray2D(exampleC); // Works
        toIntArray2D(exampleD); // Works
        toIntArray2D(exampleE); // Works
    }

    private static ArrayList<ArrayList<Integer>> createTestLists()
    {
        ArrayList<ArrayList<Integer>> adjList =
            new ArrayList<ArrayList<Integer>>();

        ArrayList<Integer> adjList0 = new ArrayList<Integer>();
        adjList0.add(0);
        adjList0.add(1);
        adjList0.add(2);
        adjList.add(adjList0);

        ArrayList<Integer> adjList1 = new ArrayList<Integer>();
        adjList1.add(3);
        adjList1.add(4);
        adjList.add(adjList1);

        ArrayList<Integer> adjList2 = new ArrayList<Integer>();
        adjList2.add(5);
        adjList2.add(6);
        adjList2.add(7);
        adjList2.add(8);
        adjList.add(adjList2);
        return adjList;
    }

}

附注：考虑到你应该usually program to an interface这样的声明，如

ArrayList<ArrayList<Integer>> adjList;

任何时候都不应该永远出现在实际代码中。它应该是一个

List<List<Integer>> adjList;

如何从ArrayList的ArrayList获取二维数组？

2 个答案: