Question

我对遍历多维ArrayList感到困惑。我看到了一些有关它的话题，它们看起来很复杂。具体来说是被接受的在这里回答： How to iterate through two dimensional ArrayList using iterator? 可以像这种方法吗？遍历arrayList并将值复制到数组：

private void reassembleArray(int[] array, ArrayList<ArrayList<Integer>> buckets) {
    Iterator<ArrayList<Integer>> it = buckets.iterator();   
    int i = 0;
    while (it.hasNext()) {
        ArrayList<Integer> intList = it.next();
        Iterator<Integer> itInteger = intList.iterator();
        while (itInteger.hasNext()) {
            array[i] = itInteger.next();
            i++;
       }
   }
}

使用这种简单形式会有任何危险或副作用吗？

这是完整的程序，它是一种称为基数排序的排序算法的实现。

import java.util.ArrayList;
import java.util.Iterator;

/**
 * Radix sort implementation
 */
public class RadixSort {

/**
 * Runs the program
 */
public static void main(String[] args) {
  int[] array = {315, 418, 591, 260, 533, 58, 976, 938,};
  System.out.println("Radix sort implementation");
  printArray(array);
  sort(array, 3); // 3 is the maximun number of digits in all array elements to sort
  printArray(array);
}

/*
 * sort array of integers using radix sort algorithm
 * @param array The array
 * @param n the maximum number of digits in array elements
 */
private void sort(int[] array, int n) {
  int digitNumber = 0;
  while (digitNumber < n) {
    ArrayList<ArrayList<Integer>> buckets = initBuckets();
    // store each element in the bucket corresponding to the (digitNumber + 1)th 
    // digit of that element
    for (int i = 0; i < array.length; i++) {
      int value = array[i];
      int bucket = (value / (int) (Math.pow(10, digitNumber))) % 10;
      buckets.get(bucket).add(value);
    }
    reassembleArray(array, buckets);
    digitNumber++;
  }
}

/*
 * Initialize buckets ArrayList 
 * @return The buckets ArrayList
 */
private ArrayList<ArrayList<Integer>> initBuckets() {
  ArrayList<ArrayList<Integer>> buckets =  new ArrayList<ArrayList<Integer>>();
  // a bucket for each digit from 0 to 9
  for(int i = 0; i < 10; i++) {
    buckets.add(new ArrayList<Integer>());
  }
  return buckets;
}

/*
 * Reassemble the array 
 * @param array The array
 * @param buckets The buckets
 */
private void reassembleArray(int[] array, 
    ArrayList<ArrayList<Integer>> buckets) {
  Iterator<ArrayList<Integer>> it = buckets.iterator();   
  int i = 0;
  while (it.hasNext()) {
      ArrayList<Integer> intList = it.next();
      Iterator<Integer> itInteger = intList.iterator();
      while (itInteger.hasNext()) {
          array[i] = itInteger.next();
          i++;
      }
  }
}

/*
 * Prints an array of integers on a single line
 * @param array The array
 */
private void printArray(int[] array) {
  System.out.print("array: {");
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + ((i == array.length - 1) ?"" : ", "));
  }
  System.out.println("}");
}
}

该算法仅需要通过多个步骤对集合进行排序，首先按照右边的第一位对集合进行排序，并在保持集合初始顺序的同时，根据最后一位将所有在0到9的存储区中的元素保持不变，然后从存储区0开始重新对集合进行重新配置并继续进行操作根据左边的下一位数字排序，依此类推。

程序确实可以工作，并且可以对收藏进行排序。

Answer 1

我敢打赌，您得到的输出与您期望的输出不同，因为以下行会导致：

array[i] = itInteger.next();

类型不匹配：无法从Integer转换为int []

据我了解，您想将List<List<Integer>>结构转换为相同类型的数组。您还需要使用Integer将int映射到Stream::mapToInt：

int array[][] = new int[buckets.size()][];
IntStream.range(0, buckets.size())
         .forEach(i -> array[i] = buckets.get(i)
                                         .stream()
                                         .mapToInt(j -> j.intValue())
                                         .toArray());

System.out.println(Arrays.deepToString(array));   // Prints the very same output

此外，您无需使用Iterator，但是如果您坚持使用它：

int outerIndex = 0;
while (outerIterator.hasNext()) {
    List<Integer> list = outerIterator.next();
    Iterator<Integer> innerIterator = list.iterator();
    array[outerIndex] = new int[list.size()];
    int innerIndex = 0;
    while (innerIterator.hasNext()) {
        array[outerIndex][innerIndex] = innerIterator.next().intValue();
        innerIndex++;
    }
    outerIndex++;
}

使用这种简单形式是否有危险或副作用？

是的，这两种解决方案都是因为它们既不修改原始输入资源也不影响其他资源。

Answer 2

如果使用enhanced for loops而不是迭代器，您的代码将更加清晰：

int i = 0;
for (List<Integer> intList : buckets) {
    for (int value : intList) {
        arr[i++] = value;
    }
}

遍历多维ArrayList

2 个答案: