Java递归如何

Question

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

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();
    }
}

Answer 1

也许你想要这样的东西

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 运算符进行递归搜索。