0

我有 3 个数组列表，每个都有size = 33 个数组length = 3。我想以下列方式将数据从数组列表复制到数组，但使用任何循环（即每个循环）。

在此处输入图像描述

myArray1[1] = arraylist1.get(1);
myArray1[2] = arraylist2.get(1);
myArray1[3] = arraylist3.get(1);

我已经一个一个地手动完成了，没有使用任何循环，但是代码看起来很庞大，因为将来我确信我的数组列表和数组的数量将增加到 15 个。

我想将数据从数组列表复制到数组中，如图所示，但不是一个一个地手动使用循环吗？

4

3 回答 3

1

您需要有两个额外的结构：

int[][] destination = new int [][] {myArray1, myArray2,myArray3 }
List<Integer>[] source;
    source = new List<Integer>[] {arraylist1,arraylist2,arraylist3}

    myArray1[1] = arraylist1.get(1);
    myArray1[2] = arraylist2.get(1);
    myArray1[3] = arraylist3.get(1);

    for (int i=0;i<destination.length;i++) {
      for (int j=0;j<source.length;j++) {
        destination[i][j] = source[j].get(i);
      }
    }
于 2013-05-22T07:05:36.680 回答
1

这个怎么样？

    List<Integer> arraylist0 = Arrays.asList(2,4,3);
    List<Integer> arraylist1 = Arrays.asList(2,5,7);
    List<Integer> arraylist2 = Arrays.asList(6,3,7);
    List<List<Integer>> arraylistList = Arrays.asList(arraylist0, arraylist1, arraylist2);

    int size = 3;
    int[] myArray0 = new int[size];
    int[] myArray1 = new int[size];
    int[] myArray2 = new int[size];
    int[][] myBigArray = new int[][] {myArray0, myArray1, myArray2};

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            myBigArray[i][j] = arraylistList.get(j).get(i);
        }
    }

解释一下，由于我们希望能够处理任意size（3、15 或更多），我们正在处理二维数据。

我们也在处理arrayand List，它们的用法略有不同。

您的问题的输入是List<Integer>，因此我们制作了一个List<List<Integer>>以便轻松处理所有输入数据。

同样，输出将是数组，因此我们制作了一个二维数组 ( int[][]) 以便于写入数据。

然后只需在 2 个嵌套for循环中迭代数据即可。请注意，此行颠倒了i和j的顺序，以便按照您想要的方式拼接数据。

    myBigArray[i][j] = arraylistList.get(j).get(i);

然后你可以像这样打印你的答案：

    System.out.println(Arrays.toString(myArray0));
    System.out.println(Arrays.toString(myArray1));
    System.out.println(Arrays.toString(myArray2));
于 2013-05-22T07:21:33.613 回答
-1

如果您找不到现成的 API 或函数，我建议使用 List.toArray() 方法简化从 List 到 Array 的转换，并专注于将给定的列表集转换/转换为另一组包含所需的输出。以下是我认为可以实现此目的的代码示例。它确实假设输入列表不是固定/相同大小的。假设这只会使逻辑更容易。

返回此函数时，您需要做的就是遍历 TreeMap 并使用 List.toArray() 将值转换为数组。

public static TreeMap<Integer, List<Integer>> transorm(
        List<Integer>... lists) {

    // Return a blank TreeMap if not input. TreeMap explanation below.
    if (lists == null || lists.length == 0)
        return new TreeMap<>();

    // Get Iterators for the input lists
    List<Iterator<Integer>> iterators = new ArrayList<>();
    for (List<Integer> list : lists) {
        iterators.add(list.iterator());
    }

    // Initialize Return. We return a TreeMap, where the key indicates which
    // position's integer values are present in the list which is the value
    // of this key. Converting the lists to arrays is trivial using the
    // List.toArray() method.
    TreeMap<Integer, List<Integer>> transformedLists = new TreeMap<>();

    // Variable maintaining the position for which values are being
    // collected. See below.
    int currPosition = 0;

    // Variable which keeps track of the index of the iterator currently
    // driving the iteration and the driving iterator.
    int driverItrIndex = 0;
    Iterator<Integer> driverItr = lists[driverItrIndex].iterator();

    // Actual code that does the transformation.
    while (driverItrIndex < iterators.size()) {

        // Move to next driving iterator
        if (!driverItr.hasNext()) {
            driverItrIndex++;
            driverItr = iterators.get(driverItrIndex);
            continue;
        }

        // Construct Transformed List
        ArrayList<Integer> transformedList = new ArrayList<>();
        for (Iterator<Integer> iterator : iterators) {
            if (iterator.hasNext()) {
                transformedList.add(iterator.next());
            }
        }

        // Add to return
        transformedLists.put(currPosition, transformedList);
    }

    // Return Value
    return transformedLists;
}
于 2013-05-22T07:57:16.700 回答