Динамическая структура для цикла

Question

Я не могу обернуть голову вокруг следующего, скажем, у меня есть Список, каждый список содержит цикл «будет». каждая последовательность должна быть в пределах друг друга.

Итак, если у меня есть список с 3 объектами, я хочу

class Focus {
    String focus;
    List<String> values;

    public Focus(String focus, String... values) {
        this.focus = focus;
        this.values = Lists.newArrayList(values);
    }
}

List<Focus> focuses = new ArrayList<Focus>();
focuses.add(new Focus("Focus 1", "09", "14", "13", "12"));
focuses.add(new Focus("Focus 2", "94", "92"));
focuses.add(new Focus("Focus 3", "A", "B"));

String my_string = "";
for (Focus obj1 : list_obj_x) {
    for (Focus obj2 : list_obj_xx) {
        for (Focus obj3 : list_obj_xxx) {
            my_string += obj1 + " " + obj2 + " " + obj3;
        }
    }
}

очевидно, что со списком структура цикла for может расти, а описанное выше невозможно. мне нужна динамическая структура для удовлетворения потребностей my_string. то есть:

94    09    A
94    14    A
94    13    A
94    12    A
94    09    B
94    14    B
94    13    B
94    12    B
92    09    A
92    14    A
92    13    A
92    12    A
92    09    B
92    14    B
92    13    B
92    12    B 

вывод должен быть как выше. это то, что я до сих пор:

int focusCount = focuses.size();
for (int i = (focusCount - 1); i >= 0; i--) {
    Focus currentFocus = focuses.get(i);
    List<String> currentFocusValues = currentFocus.values;

    for (int cfv = 0; cfv < currentFocusValues.size(); cfv++) {
        String currentFocusValue = currentFocusValues.get(cfv);

        for (int j = (i - 1); j >= 0; j--) {
            Focus previousFocus = focuses.get(j);
            List<String> previousFocusValues = previousFocus.values;

            for (int pfv = 0; pfv < previousFocusValues.size(); pfv++) {
                String previousFocusValue = previousFocusValues.get(pfv);
                System.out.println(currentFocusValue + " " + previousFocusValue);
            }
        }
    }
}

обслуживает все комбинации значений списка, но не в той структуре, которую я хочу.

Может кто-нибудь помочь мне?

Answer 1

Самым простым подходом, вероятно, будет рекурсия.На каждом шаге рекурсии вы «закрепляете» значение n-го списка один за другим, затем повторяете вниз «список списков», пока не достигнете конца.

String[] values = new String[focuses.size()];
CreateCombinations(focuses, 0, values);

С помощьюрекурсивный метод

private void CreateCombinations(List<Focus> focuses, int index, string[] values) {
    Focus focus = focuses.get(index);
    for (string v : focus.values) {
        values[index] = v;
        if (index < focuses.size() - 1) {
            // there is at least one other focus
            CreateCombinations(focuses, index+1, values);
        } else {
            // all values pinned down
            StringBuilder sb = new StringBuilder(values[0]);
            for (int i = 1; i < values.length; ++i) {
                sb.append(" ").append(values[i]);
            }
            // now do whatever you like to do with sb.toString()...
        }
    }
}

Конечно, это можно уточнить, но, возможно, этого будет достаточно в качестве отправной точки для вас.

Answer 2

Вот итеративный подход (нужно все еще очистить):

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

public class Focus {
    String focus;
    List<String> values;

    public Focus(String focus, String... values) {
        this.focus = focus;
        this.values = Arrays.asList(values);
    }

    public static String printAllCombinations(Focus... focuses) {
        String myString = "";
        List<String> allCombinations = new ArrayList<String>();

        int length = focuses.length;

        if (length == 0) {
            return "";
        } else if (length == 1) {
            allCombinations = focuses[0].values;
        } else if (length > 1) {
            for (Focus f : focuses) {
                allCombinations = getCombinations(allCombinations, f.values);
            }
        } 

        for (String s : allCombinations) {
            myString += s+"\n";
        }

        return myString;
    }

    private static List<String> getCombinations(List<String> l1, List<String> l2) {
        if (l1.size() == 0) {return l2;}
        else if (l2.size() == 0) {return l1;}

        List<String> combinations = new ArrayList<String>();
        for (String outerValue : l1) {
            for (String innerValue : l2) {
                combinations.add(outerValue + " " + innerValue);
            }
        }
        return combinations;
    }
}

Answer 3

Как уже упоминал Курт, вам нужно всего две петли.

У вас есть список объектов, Фокус объекта. У каждого объекта есть список значений. Следовательно, вам нужен один внешний цикл для просмотра списка объектов и другой цикл для просмотра списка значений для обрабатываемого объекта:

mystring = ""
int m = get the length of focuses list
for (1 through m) {
 int n = geht the length of values list for the current Focus object
 for (1 through n) {
    myString += current value;
 }

}

Answer 4

У вас есть только 2 цикла: 1 для объектов фокуса и 1 для их значений.