1

我有一个只存储两个整数的类：

public class Item
{
    private int from;
    private int to;

    public Item(int from, int to)
    {
        this.from = from;
        this.to = to;
    }
    getters and setters
}

在运行时，我将创建这些项目的列表。该列表将包含 1 到 21 个值。然后我需要遍历这些值并进行一些处理。例如：

public void validate()
{
    List<Item> items = new ArrayList<Item>();
    items.add(new Item(1,3));
    items.add(new Item(11,13));
}

或者：

public void validate()
{
    List<Item> items = new ArrayList<Item>();
    items.add(new Item(1,3));
    items.add(new Item(11,13));
    items.add(new Item(21,23));
}

然后我需要循环这些值。显然我不知道要循环多少级，所以我不能硬编码一个循环。如果可以的话，循环将如下所示：

public void loop()
{
    String str;
    for(int i = 1; i < 3; i++)
    {
        str = "-" + i;
        for(int j = 11; j < 13; j++)
        {
            str = str + "-" + j;
            do stuff with str;
        }
    }
}

我需要在这里测试的输出是：

-1-11
-1-12
-1-13
-2-11
-2-12
-2-13
-3-11
-3-12
-3-13

第二个例子是：

public void loop()
{
    String str;
    for(int i = 1; i < 3; i++)
    {
        str = "-" + i;
        for(int j = 11; j < 13; j++)
        {
            str = str + "-" + j;
            for(k = 21; k < 32; k++)
            {
                str = str + "-" + k;
                do stuff with str;
            }
        }
    }
}

我需要在这里测试的输出是：

-1-11-21
-1-11-22
-1-11-23
-1-12-21
-1-12-22
...
-2-11-21
-2-11-22
...
-3 -13-21

因为我不知道有多少个循环，所以我想我需要使用递归。但是，我不知道如何在递归的内部循环中“用 str 做事”，我开始认为这是不可能的。

这就是我在这里尝试的方式：

private void recursiveExplore(List<Item> items, int depth)
{
    if (depth == 0) return;

    for (Item item : items)
    {
        for (int i = item.getFromParameterId(); i < item.getToParameterId(); i++)
        {
             do stuff here?
        }
        recursiveExplore(items.subList(items.size() - depth, items.size()), depth - 1);
    }
}

public void validate()
{
    recursiveExplore(items, items.size());
}

任何帮助表示赞赏。

ETA SSCCE：

import java.util.ArrayList;
import java.util.List;

public class MyTest
{
    private class Item
    {
        private int from;
        private int to;

        public Item(int from, int to)
        {
            this.from = from;
            this.to = to;
        }

        public int getFrom()
        {
            return from;
        }

        public int getTo()
        {
            return to;
        }
    }

    public void validate2()
    {
        List<Item> items = new ArrayList<Item>();
        items.add(new Item(1, 3));
        items.add(new Item(11, 13));

        String str;
        for (int i = items.get(0).getFrom(); i <= items.get(0).getTo(); i++)
        {
            for (int j = items.get(1).getFrom(); j <= items.get(1).getTo(); j++)
            {
                str = "-" + i + "-" + j;
                System.out.println(str);
            }
        }
    }

    public void validate3()
    {
        List<Item> items = new ArrayList<Item>();
        items.add(new Item(1, 3));
        items.add(new Item(11, 13));
        items.add(new Item(21, 23));

        String str;
        for (int i = items.get(0).getFrom(); i <= items.get(0).getTo(); i++)
        {
            for (int j = items.get(1).getFrom(); j <= items.get(1).getTo(); j++)
            {
                for (int k = items.get(2).getFrom(); k <= items.get(2).getTo(); k++)
                {
                    str = "-" + i + "-" + j + "-" + k;
                    System.out.println(str);
                }
            }
        }
    }

    public static void main(String[] args)
    {
        MyTest test = new MyTest();
        test.validate2();
        test.validate3();
    }
}
4

3 回答 3

0

在检查你的循环之后，我设想你最终需要在两者之间更新str变量-。如果是这样，那么你就在写轨道上。

private void recursiveExplore(List<Item> items, int depth, int str) {
    if (depth == 0) return;

    for (Item item : items) {
        for (int i = item.getFromParameterId(); i < item.getToParameterId(); i++) {
             str += "-" + i;
        }
        // Just need to concatenate the output of nested call
        str += recursiveExplore(items.subList(items.size() - depth, items.size()), depth - 1, str);
    }
    return str;
}

public void validate() {
    String finalStr = recursiveExplore(items, items.size(),"");
}

没试过，但可能需要稍微调整一下。

于 2012-11-28T09:52:21.537 回答
0

在一位同事的帮助下，我已经完成了我需要的代码（见下文）。它不是很完整，但主要结构就在那里。
感谢您的所有帮助，如果没有您的帮助，我也无法做到这一点。

public void validateFiles()
{
    List<String> outputList = new ArrayList<String>();
    recursiveCompile(items, 0, null, outputList);
}

private void recursiveCompile(ArrayList<Item> items, int itemIndex,
        String compilation, List<String> outputList)
{
    if (itemIndex < items.size())
    {
        /* Get the item from the list. */
        Item item = items.get(itemIndex);
        /* Prepare the variables for the descent. */
        itemIndex++;
        if (compilation == null) compilation = "";
        /* Descend for each value in the from/to range. */
        for (int i = item.getFromParameterId(); i <= item.getToParameterId(); i++)
        {
            String s = compilation + "-" + item.getNextValue();
            recursiveCompile(items, itemIndex, s, outputList);
        }
    }
    else
    {
        /*
         * The bottom has been reached. Add the compiled string to the
         * output list and ascend (return).
         */
        outputList.add(compilation);
        return;
    }
}
于 2012-11-29T11:17:46.177 回答
0

也许你想要这样的东西

public class Item(){}

public class ListItem extends Item(){} //here you have a List of items
public class ObjectItem extends Item() {} //here you have only one item

因此，您可以使用 instanceof 运算符进行递归搜索。

于 2012-11-28T09:45:49.003 回答