java - 查找多个列表中的元素数量并合并；删除 if/else 复杂？

Question

我有一个列表列表:

List<List<String>> someList = new List<List<>>();

列表的最大大小为五个字符串。就像下面这样:

someList.get(0).size(); // 4 elements
someList.get(1).size(); // 1 elements
someList.get(2).size(); // 3 elements
someList.get(3).size(); // 1 elements
...

我正在尝试设计一种方法，通过组合上述一些嵌套列表来创建特定大小(1-5 个元素)的新列表。我可以做类似下面的事情(在这个例子中，三个元素):

public List<String> getThree() {
    for (int j = 0; j < someList.size(); j++) {
        //look for nested lists of size 3
        if (someList.get(j).size() == 3) {
            return someList.get(j);
        }
    for (int j = 0; j < someList.size(); j++) {
        //if found nested list of size 2, find one of size 1 to combine
        if (someList.get(j).size() == 2) {
            for (int k = 0; k < someList.size(); k++) {
                if (someList.get(k).size() == 1) {
                    return someList.get(j).add(someList.get(k).get(0));
                }
            }
        }
    for (int j = 0; j < someList.size(); j++) {
        //if found nested list of size 1, find one of size 2 to combine
        if (someList.get(j).size() == 1) {
            for (int l = 0; l < someList.size(); l++) {
                if (someList.get(l).size() == 2) {
                    return someList.get(j).addAll(someList.get(l));
                }
            }
        }
    }
}

我没有包含如果没有大小为 2 的子列表，找到三个大小为 1 的循环，但您可以想象它会变得多长和多难看。顺序很重要，因此 for 循环按顺序递增(即，我宁愿组合 subList 1 + 2 而不是 2 + 3，1 + 3 多于 2 + 3，等等)。

我希望找到一种动态实现它的方法。我只能理解 getFive 方法在我当前的方法中的可读性和长度。我有多种方法(getOne 到 getFive)，在这个意义上它不需要是动态的，我只是想摆脱很多 if/else 和 for 循环以降低复杂性并提高可读性。

我应该提到这是与家庭作业相关的，所以我不太想要一个具体的答案，而是朝着正确的方向轻推。也许是 modulo？如何处理余数？

编辑；澄清并举个例子:

aList = new List<String>;
aList.add("a");
aList.add("b");
someList.add(aList);
bList = new List<String>;
bList.add("c");
someList.add(bList);
newList = someList.getThree();
//newList.size() == 3
//newList contains "a","b","c"

getThree() 方法正在创建一个新列表，该列表由 someList 的子列表中的元素组成。它不能拆分子列表(即它不能从 2 个元素的子列表中取出 1 个元素)，它组合整个子列表。

Answer 1

如果您打算继续从连续的列表中收集直到获得 5 个元素，请继续添加，然后在列表已满时中断:

public static List<String> fill(List<List<String>> sources, int size) {
    List<String> list = new ArrayList<>();
    for (List<String> source : sources) 
        if (source.size() <= size - list.size()) 
            list.addAll(source);
    return list;
}

如果你想先消费最大的列表，添加这行作为方法的第一行:

Collections.sort(sources, (a, b) -> b.size() - a.size());

---

在 java 8 中，非常简洁:

public static List<String> fill(List<List<String>> sources, int size) {
    return sources.stream().reduce(new ArrayList<>(), 
      (a, b) -> {if (b.size() <= a.size() - size) a.addAll(b); return a;});
}

并使用最大优先模式:

public static List<String> fill(List<List<String>> sources, int size) {
    return sources.stream()
        .sorted((a,b) -> b.size() - a.size())
        .reduce(new ArrayList<>(), (a, b) -> 
            {if (b.size() <= a.size() - size) a.addAll(b); return a;});
}