Java 中的递归枚举

Question

我还有一个关于枚举的问题。以下是情况的简要概述。 我有一个 Backpack 类，它有一个 Hashmap 内容，其键为 long 类型的变量，值为带有 Items 的 ArrayList。 我必须编写一个枚举来迭代背包的内容。但这里有一个问题：在一个背包中，还可以有另一个背包。并且枚举还应该能够迭代背包中背包的内容。 （我希望你能理解，我不太擅长解释..）

这是我的代码：

public Enumeration<Object> getEnumeration() {
    return new Enumeration<Object>() {
        private int itemsDone = 0;
        //I make a new array with all the values of the HashMap, so I can use
        //them in nextElement()
        Collection<Long> keysCollection = getContent().keySet();            
        Long [] keys = keysCollection.toArray(new Long[keysCollection.size()]);

        public boolean hasMoreElements() {
            if(itemsDone < getContent().size()) {
                return true;
            }else {
                return false;
            }

        }

        public Object nextElement() {               
            ArrayList<Item> temporaryList= getContent().get(keys[itemsDone]);
            for(int i = 0; i < temporaryList.size(); i++) {
                if(temporaryList.get(i) instanceof Backpack) {
                    return temporaryList.get(i).getEnumeration();                       
                }else {
                    return getContent().get(keys[itemsDone++]);
                }
            }
        }
    };

这段代码可以正常工作吗？这只是“return temporList.get(i).getEnumeration();”我很担心。用户仍然可以像通常那样使用 hasMoreElemens() 和 nextElement() 吗？

感谢任何帮助，

Harm De Weirdt

Answer 1

您需要创建一个Stack>。当您看到另一个Backpack时，您push该元素上的一个新Enumeration到Stack中。您始终从堆栈顶部开始nextElement()。如果顶部元素为空，则将其弹出。重复直到Stack.isEmpty()。

---

另一种可能更简单的技术（取决于您对递归的适应程度）是使用“内部”枚举，它本身可以具有内部枚举。以下是在 Object[] 上使用 Iterator 的代码示例。它递归地迭代到任何嵌套的Object[]。

public class RecursiveIterator implements Iterator<Object> {
    final Object[] arr;
    int index = 0;
    Iterator<Object> inner;
    RecursiveIterator(Object[] arr) {
        this.arr = arr;
    }
    @Override public boolean hasNext() {
        while (true) {
            if (inner != null) {
                if (inner.hasNext()) {
                    return true;
                } else {
                    inner = null;
                    index++;
                }
            }
            if (index == arr.length) return false;
            if (arr[index] instanceof Object[]) {
                inner = new RecursiveIterator((Object[]) arr[index]);
            } else {
                return true;
            }
        }
    }
    @Override public Object next() {
        if (!hasNext()) throw new NoSuchElementException();
        return (inner != null) ? inner.next() : arr[index++];
    }
    @Override public void remove() {
        throw new UnsupportedOperationException();
    }       
}

这是一个测试工具：

static void dump(Object[] arr) {
    Iterator<Object> iter = new RecursiveIterator(arr);
    while (iter.hasNext()) {
        System.out.print(iter.next() + " ");
    }
    System.out.println("(done)");
}
public static void main(String[] args) throws FileNotFoundException {
    dump(new Object[] {
        1,
        2,
        new Object[] {
            3,
            new Object[] { 4 },
            5,
        },
        6,
        new Object[] {},
        7,
    });
    dump(new Object[] {
        new Object[] {},
        new Object[] {
            new Object[] {          
                new Object[] {},
            },
        },
        new Object[] {},
        new Object[] { null },
    });
}

打印：

1 2 3 4 5 6 7 (done)
null (done)

Answer 2

如果它是出于实用目的而不是家庭作业，我会使用 迭代器接口而不是旧的枚举。对于迭代器，您有一些 apache 集合项目中的不错的实用程序。

其次，您的解决方案似乎有一个错误。方法 nextElement() 应该返回元素本身，但是 return temporList.get(i).getEnumeration() 行却返回一个 Enumeration 对象。

--编辑--

多基因润滑剂提出了一个很好、优雅的解决方案。我想到了别的事。您可以实现一个通用的 ChainEnumeration 类（实现枚举），它接收枚举列表并允许枚举基础项。在您的树结构中，返回一个简单的枚举，其中一项为叶子，以及一个内部节点的链枚举。

ChainEnumeration 的实现很简单：它管理一个迭代器列表，以及对当前活动迭代器的引用，其中的项目是从该迭代器中获取的。