Question

在Java中如何在不使用任何循环结构的情况下遍历ArrayList？

Answer 1

你可以使用递归。

public void doSomethingToAll(List list)
{
    // Begin the recursion.
    doSomethingToAll(list, 0);
}

private void doSomethingToAll(List list, int index)
{
    // Break the recursion when we have processed the entire list.
    if (index >= list.size()) return;

    // Do whatever you want with the list.
    process(list.get(index));

    // Recursive step. Process the next element.
    doSomethingToAll(list, index + 1);
}

Answer 2

不是说我提供的是唯一且最好的解决方案，但它足够通用，可以轻松地重复使用，类型安全，并且允许您在遍历过程中尽早打破。

您可以轻松扩展它并使其适用于任何类型的集合。

简单的遍历实现

实施包括：

一个可重用的类型安全的Actor类，用于定义操作（如果有的话），
可重用的类型安全遍历类，
和一个用于在遍历早期中断的异常类。

通过可重用，我的意思是，一旦在集合上使用，您可以重用它而无需重新实例化，因此每个目标行为只需要一个实例。

<强>演员

interface Actor<T> {

  void act(final T element) throws TraversalInterruptionException;
}

<强>穿越

class Traversal<T> {

  int      index = 0;
  Actor<T> actor = null;


  public Traversal(final Actor<T> a) {
    actor = a;
  }

  void traverse(final List<T> col) {
    if (index < col.size()) {
      final T element = col.get(index++);
      try {
        if (actor != null) {
          actor.act(element);
        }
        traverse(col);
      } catch (final TraversalInterruptionException e) {
        /* let's get out of there early */
        index = 0; // reset
      }
    } else {
      index = 0; // reset
    }
  }
}

<强> TraversalInterruptionException

class TraversalInterruptionException extends Exception {
}

测试

  @Test
  public void test() {
    final List<String>      list          = new ArrayList<String>();
    final Traversal<String> strTraversal  = new Traversal<String>(new Actor<String>() {

      @Override
      public void act(final String element)
      throws TraversalInterruptionException {
        if ("exit".equals(element)) {
          throw new TraversalInterruptionException();
        }
        System.out.println(element);
      }
    });

    list.add("test1");
    list.add("test2");
    list.add("test3");
    list.add("exit");
    list.add("test4");

    strTraversal.traverse(list);
    strTraversal.traverse(list); // and again to test the reset
  }

输出

test1
test2
test3
test1
test2
test3

Answer 3

你可以做这样的哑巴：

void traverse(ArrayList list)
{
  traverseHelper(list, 0);
}

void traverseHelper(ArrayList list, int index)
{
  if (index == list.size())
    return;

  "visit" list.get(index);

  traverseHelper(list, index+1);
}

它使用递归而不是迭代，但为什么要这样做呢？

Answer 4

您可以尝试使用递归：

void traverse(ArrayList<Whatever> list, int cur)
{
   if (cur == list.size())
     return;
   else {
     Whatever elem = list.getAt(cur);
     System.out.println(elem);
     traverse(list, ++cur);
   }
}

void traverse(ArrayList<Whatever> list)
{
  traverse(list, 0);
}

如何在不使用循环结构的情况下遍历ArrayList？

4 个答案:

简单的遍历实现

测试

输出